Gesichtsverfolgungskamera
Autoren: Suryaa Kalamani-Ramamoorthy & Aaron-Lasse Paelmke
Betreuer: Prof. Ulrich Schneider
→ zurück zur Übersicht: WS 20/21: Angewandte Elektrotechnik (BSE)
→ zurück zur Übersicht: WS 21/22: Angewandte Elektrotechnik (BSE)
→ zurück zur Übersicht: WS 22/23: Angewandte Elektrotechnik (BSE)
Einleitung
Das Projekt "Gesichtsverfolgungskamera" wird im Rahmen des GET Fachpraktikums im 5. Semester des Studiengangs Mechatronik der HSHL am Campus Lippstadt durchgeführt. Ziel des Projekts ist die Umsetzung eines Systems, das mittels einer Webcam Gesichter erfasst und Mikrokontroller gesteuert dem erfassten Gesicht folgt und es im Fokus behält. Die Durchführung des Projekts soll die erlernten Kenntnisse der Fächer Informatik, Physik, Grundlagen der Elektrotechnik I, Grundlagen der Elektrotechnik II, Elektronische Bauelemente und Grundschaltungen, Aufbau-/ und Verbindungstechnik sowie Mess-/ und Regelungstechnik festigen, vertiefen und neue Erkenntnisse fördern.
Anforderungen
| ID | Anforderung |
|---|---|
| 1 | Allgemein |
| 1.1 | Die Kamera soll Gesichter erkennen und ein einmal erfasstes Gesicht so lange verfolgen, wie es sich im Sichtfeld aufhält. |
| 1.2 | Falls sich mehrere Gesichter im Sichtfeld aufhalten soll nur ein Gesicht erfasst und verfolgt werden. |
| 1.3 | Das System soll den aktuellen Status über LEDs darstellen. |
| 2 | Bildanalyse und Auswertung |
| 2.1 | Die von der Webcam erfassten Bilder sollen mittels eines Algorithmus auf Gesichter gescannt werden. Von den Gesichtern soll der Mittelpunkt erfasst und mit dem Mittelpunkt des Bildes verglichen werden. |
| 2.2 | Anhand der Position des erfassten Gesichts soll der Systemstatus ermittelt werden (Gesicht erkannt und zentriert/Gesicht erkannt nicht zentriert/Gesicht nicht erkannt). |
| 3 | Ausgabe |
| 3.1 | Es soll permanent der Status über LEDs angezeigt werden. |
| 3.2 | Die Servomotoren sollen über den Arduino UNO angesteuert werden und so immer versuchen ein erfasstes Gesicht zu zentrieren. |
Die Tabelle beschreibt die Anforderungen an das Projekt Gesichtserfassungskamera.
Funktionaler Systementwurf/Technischer Systementwurf
Bei den Abbildungen handelt es sich um Skizzen, die sowohl den technischen, als auch den funktionalen Systementwurf verdeutlichen sollen.
Die von der Webcam erfassten Bilder sollen an einen PC übermittelt werden, auf dem eine Software zur Gesichtserkennung läuft. Die Aufnahmen der Webcam sollen auf Gesichter gescannt werden. Die Position des Gesichts auf den Fotos der Webcam soll zentriert werden, wodurch sich ableiten lässt, in welche Richtung sich die Webcam bewegen muss, damit das Gesicht zentriert wird. Zwischen dem PC und dem Arduino UNO Mikrokontroller soll ein Datenaustausch stattfinden, um die Informationen, wie der Arduino die zwei Servomotoren ansteuern soll zu übertragen.
-
Abb. 1: Funktionaler Systementwurf
-
Abb. 2: Verkabelungsdiagramm
-
Abb. 3: Skizze des Aufbaus
Abbildung 2 zeigt den Verkabelungsplan der Gesichtsverfolgungskamera. Im Folgenden wird die Schaltung erklärt, sowie die Vorgehensweise beim Aufbau betrachtet.
Zunächst wurde die Schaltung auf einem Breadboard aufgebaut und auf ihre Funktion geprüft. Auf diese Weise wurde ebenfalls die Funktion der verwendeten Aktoren kontrolliert. Die Aufgabe der Schaltung ist das Versorgen der Servomotoren mit einer Betriebsspannung von 5 V, sowie das Verbinden der LEDs mit den vorgesehenen Pins des Arduino Mikrokontrollers.
Eingespeist werden 9 V über ein Netzteil. Parallel an die Buchse angeschlossen sind sowohl ein Spannungsbegrenzer, als auch die Eingangspins des Arduino UNO. Auf Pin VIN wurden die 9 V gelegt, auf den Pin GND wurde GND gelegt. Der Spannungsbegrenzer verringert die Spannung von 9 V auf 5 V und ermöglicht somit einen sicheren Betrieb der Servomotoren, deren maximale Betriebsspannung bei 6 V liegt. Die PWM Signale für die Motoren wurden von den Pins 8 und 9 des Arduino abgegriffen.
Je nach Status des Programms gibt der Arduino UNO Signale an die LEDs aus. Die Signale der LEDs wurden an den digitalen Ausgangspins 2, 3 und 4 entnommen. Jeweils die Anode der LED wurde an den Pin mit dem Signal angesteuert, wobei die Grüne LED auf Pin 4 gelegt ist, die Gelbe auf Pin 3 und die Rote auf Pin 2. Ein Vorwiderstand von 220 Ohm schützt die LEDs vor einer zu hohen Betriebsspannung. Die Anoden der LEDs wurden auf GND am Arduino Mikrokontroller gelegt.
Komponentenspezifikation
Für das Projekt "Gesichtsverfolgungskamera" kamen diverse Bauteile zum Einsatz. Diese werden im Folgenden aufgeführt und näher betrachtet. Für die einzelnen Komponenten werden ihre Eigenschaften und Spezifikationen dargestellt und beschrieben, sowie auf ihre Funktion im Projekt eingegangen.
Arduino UNO
Bei dem Arduino UNO (Abb. 4) handelt es sich um einen Mikrokontroller. Dieser Mikrokontroller basiert auf dem ATmega328P. Der Arduino UNO zeichnet sich durch 14 digitale Ein-/ und Ausgangspins aus, von denen 6 als PWM-Ausgänge genutzt werden können. Der Arduino verfügt über einen 16 MHz Keramikresonator, einen USB-Slot, eine Spannungsbuchse und einen ICSP Header. Überdies verfügt der Arduino zusätzlich über einen Resett-Knopf.
MG-90S Servomotoren
Die Servomotoren zeichnen sich durch eine kompakte Baugröße aus. Das Getriebe der Servomotoren besteht aus Metallzahnrädern und zeichnet sich dadurch durch eine vergrößerte Lebensdauer im Vergleich zu Plastikzahnrädern aus. Ebenso kann ein größeres Drehmoment übertragen werden. Der Operationsbereich der Motoren beträgt insgesamt 180 Grad (90 Grad in jede Richtung). Die Servomotoren werden mit einer Spannung von 4,8 V bis zu 6 V betrieben. Im Anwendungsfall der Gesichtserkennungskamera beträgt die angelegte Spannung 5 V. Nebenstehend ist in Abb. 6 ein Servomotor des Typs dargestellt.
Webcam
Bei der Verwendeten Webcam handelt es sich um die HD Pro PC Webcam (Model No. AWCAMHD15) des Herstellers Advent. Die verwendete Webcam zeichnet sich durch die Fähigkeit aus Videos in full HD aufzunehmen. Die Aufnahme funktioniert über den internen HD1080P CMOS Sensor. Der Sensor besitzt eine Auflösung von bis zu 2 Megapixel für Videoaufnahmen. Objekte die weiter als 3 cm entfernt sind können Fokussiert werden. Die mögliche Framerate der Webcam beträgt bis zu 30 fps.
LEDs
Bei den verwendeten LEDs handelt es sich um gewöhnliche Leuchtdioden in den Farben Grün, Gelb und Rot. Wie nebenstehend, in Abbildung 7, den Kennlinien der LEDs zu entnehmen ist, liegen die Schwellenspannungen der LEDs eng beieinander. Dieses ähnliche Schaltverhalten führt dazu, dass alle LEDs an der gleichen Spannung mit gleich dimensionierten Vorwiderständen betrieben werden können. Wie zuvor beschrieben werden die LEDs von den digitalen Ausgangspins 2, 3 und 4 des Arduino UNO angesteuert.
Umsetzung (HW/SW)
Hardware
Das Adruino-Gehäuse, der Kamerahalter, die Halterung für die Servomotoren und das Stativ wurden mit der CAD-Software Solidworks entworfen und mittels additiver Fertigung (3D-Druck) gefertigt. Die folgenden Abbildungen sind ein Ausschnitt aus den CAD-Entwürfen.
-
Abb. 5: CAD Ansicht Gehäuse
-
Abb. 6: CAD Ansicht Halter für Servomotoren
-
Abb. 7: CAD Ansicht Kamerastativ
-
Abb. 8: CAD Ansicht Webcamhalter
3d-druck material ergänzen
Montage und Verdrahtung
Die Grundplatte des Gehäuses (Abb. 5) ist der Arduino UNO Mikrokontroller. Dieser wird mittels Schrauben im Gehäuse befestigt. An der Rückseite des Gehäuses befinden sich zwei Steckplätze für die Anschlüsse der Versorgungsspannung und des USB Typ B Steckers, mit dem die Verbindung zwischen Arduino und PC hergestellt wird. Die Verdrahtung des Projekts wurde im Gehäuse versteckt.
Software
Im folgenden ist das Programm für die Steuerung der Gesichtsverfolgungskamera dargestllt. Der Code ist im SVN unter folgendem Link zu finden: SVN_Ordner
Matlab/Simulink 2019b Documentation von MathWorks ist die in diesem Projekt hauptsächlich verwendete Software.
Kommunikation
Zu Beginn ist die Kommunikation zwischen der Hardware und dem Computer erforderlich. In diesem Projekt werden zahlreiche Toolboxen und Bibliotheken verwendet, z.B. die Image Acquisition Toolbox, um Bilder von der Webkamera zu erhalten, die Computer Vision Toolbox für die Bildverarbeitung und die Kommunikationsschnittstelle zwischen dem Arduino Mikrocontroller und dem Computer.
Im folgenden Softwareskript gibt die Header-Datei einen Überblick darüber, welche Tools und Bibliotheken verwendet werden. Anschließend wird die Kommunikationsschnittstelle dieses Projekts erläutert, z. B. der Handshake des Servomotors und die Auswahl der Bildauflösung.
%% ***********************************************************************\
%
% Modul : Gesichtverfolgungskamera.m
%
% Datum : 20.10.2022
%
% Beschreibung : Die vollständige Implementierung von Bildverarbeitung
% und Gesichverfolgung
%
% Implementierung : MATLAB R2019b
%
% Toolbox : 1. Matlab Webcam Support package,
% 2. Adruino support package for matlab,
% 3. Computer Vission toolbox
%
% Autor : Kalamani, Suryaa und Laase, Aaron
%
% Bemerkung :
%
% Letzte Änderung : 07.12.2022
%
%*************************************************************************/
%%
% Workplace aufräumen
clear all
clc
%% Objekt erstenn - Kommunikation zwischen Matlab und Arduino
if ~exist('a_Obj', 'var')
a_Obj = arduino('COM3','Uno','Libraries','Servo');
% Pin belege 8 und 9 entspechricht die Pan und Tilt Servo
panServo = servo(a_Obj,'D8');
tiltServo = servo(a_Obj,'D9');
%% Kommunikation für Linux oder Mac OS
%a_Obj = arduino('/dev/tty.usbmodem2101','Uno','Libraries','Servo');
%/dev/tty.usbmodem2101 For mac
end
%% Start Position Motoren - Handshake
writePosition(tiltServo,0);
writePosition(tiltServo,0.70);
%% Kamera bereitstellen
Kamera_ID = 2; % Je nach USB Schnittstellen und Port, muss die richtige Kamera ID ausgewählt werden
Kamera = webcam(Kamera_ID); % Zugriff auf Kamera durch Kamera Aquisation Toolbox
% Kamera.AvailableResolution - Mit der Funktion die passende Aufloesung auswaehlen
Kamera.Resolution = '1280x720'; %'1280x720'; %'640x480'
% Zur Bildverarbeitung und Darstellugn wird das Videoplayer Objekt erstellt
videoPlayer = vision.VideoPlayer('Position',[100 100 1280 720]);
Bildverarbeitung
Nach einem erfolgreichen Handshake zwischen dem Computer und der Hardware werden Makros für die Bildverarbeitung und weitere Vorgänge initialisiert und eine while-Schleife für eine Anzahl von n Bildern wird initialisiert.
Die folgenden Skripte erläutern jedes Makro und seine Funktion bei der Bildverarbeitung. Der Viola-Jones-Algorithmus zur Gesichtserkennung wird in diesem Projekt als Teil der Gesichtserkennung verwendet, die Attribute wie Nasen, Augen, Münder oder Oberkörper von Personen verwendet, um Gesichter zu erkennen. [1]
Einzelheiten über die Verwendung dieser Funktionen finden Sie in der Matlab-Dokumentation Viola_Cascade_Facetracking.
% Gesishterkennung mit Viola Cascade Algorithm
face_Detector = vision.CascadeObjectDetector();
point_Tracker = vision.PointTracker('MaxBidirectionalError', 2);
run_loop = true; % Speicherplatz reservierung zum Geshcitererkeunng und Schleifenbedingungen
number_of_Points = 0;
frame_Count = 0;
%% Makros - Einstellung
servomaxx_UpperLimit = 300/360; % Pan Servo Maximum und Minimum Winkel
servomaxx_LowerLimit = 60/360;
servomaxy_UpperLimit = 80/360; % Tilt Servo Maximum und Minimum Winkel
servomaxy_LowerLimit = 55/360;
screenmaxx = 1280; % Frame Grosse in X
screenmaxy = 720; % Frame Grosse in Y
distancex = 1; % Servo Rotationsschritt in X Richtung
distancey = 1; % Servo Rotationsschritt in X Richtung
incx = 240; % Inkrement der Kamerabewegung in der X-Achse
incy = 155; % Inkrement der Kamerabewegung in der Y-Achse
while run_loop && frame_Count <4000
%% Bildverarbeitung - Gesichterkennung
video_Frame = snapshot(Kamera); % Bildframe des Kamera wird gespeichert
gray_Frame = rgb2gray(video_Frame); % Bild in grayscale umgewandelt
frame_Count = frame_Count+1;
if number_of_Points <10 % Anzahl der erkannte Punkte im Bild
face_Rectangle = face_Detector.step(gray_Frame);
if ~isempty(face_Rectangle)
points = detectMinEigenFeatures(gray_Frame, 'ROI', face_Rectangle(1, :));
xy_Points = points.Location;
number_of_Points = size(xy_Points, 1);
release(point_Tracker);
initialize(point_Tracker, xy_Points, gray_Frame);
previous_Points = xy_Points;
rectangle = bbox2points(face_Rectangle(1,:));
face_Polygon = reshape(rectangle', 1, []);
video_Frame = insertShape(video_Frame, 'Polygon', face_Polygon, 'LineWidth', 3);
video_Frame = insertMarker(video_Frame, xy_Points, '+', 'Color', 'white');
end
else
[xy_Points, isFound] = step(point_Tracker, gray_Frame);
new_Points = xy_Points(isFound, :);
old_Points = previous_Points(isFound,:);
number_of_Points = size(new_Points, 1 );
if number_of_Points >= 10
[xform, old_Points, new_Points] = estimateGeometricTransform(old_Points, new_Points, 'similarity', 'MaxDistance', 4);
rectangle = transformPointsForward(xform, rectangle);
face_Polygon = reshape(rectangle', 1, []);
tic
video_Frame = insertShape(video_Frame, 'Polygon', face_Polygon, 'LineWidth', 3);
video_Frame = insertMarker(video_Frame, new_Points, '+', 'Color', 'white');
t3 = toc;
previous_Points = new_Points;
setPoints(point_Tracker, previous_Points);
end
end
.
.
.
Objektverfolgung mit Servo Motoren
Sobald ein Gesicht im Bild erkannt wird, wird die mittlere Position des Objekts (in diesem Fall die Bounding Box) relativ zu den Bildkoordinaten berechnet und als Eingabe für die Verfolgung verwendet.
Das Konzept der Verfolgung mit zwei Servomotoren ist in Abbildung 9 dargestellt, eine der Schwenk- und Neigebewegungen der Kamera. Immer, wenn sich das Objekt außerhalb des grünen Kastens befindet, wird der entsprechende Motor angewiesen, sich zu bewegen, um das Objekt in der Mitte des Bildes oder des grünen Kastens zu positionieren.
Bei jedem Bild, auch nach einer leichten Bewegung des Servomotors, wird das Objekt verfolgt und seine Position berechnet, wodurch ein Regelkreis entsteht. Die Schwenk- und Neigebewegungen der Servomotoren haben einen Bewegungsbereich, eine Ober- und eine Untergrenze, innerhalb derer sie sich bewegen dürfen. Wenn sich das Objekt außerhalb der grünen Box befindet und einer der Servomotoren seine Grenzen erreicht, werden beide Motoren auf ihre ursprüngliche Position zurückgesetzt und die Verfolgung des Objekts wird beendet.
Abbildung 10 zeigt ein vereinfachtes PAP dieses Projekts, um die Funktionsweise besser zu verstehen.
-
Abb. 10: PAP Gesichverfolgungskamera
Das folgende Skript stellt den Algorithmus zur Gesichtsverfolgung und die Bedingungen dar, unter denen die Servomotoren gesteuert werden.
while run_loop && frame_Count <4000
.
.
.
.
if isempty(face_Rectangle)
writeDigitalPin(a_Obj, 'D4', 0);
writeDigitalPin(a_Obj, 'D2', 1);
end
if(~isempty(face_Rectangle))
%LED Zustand zeigen
writeDigitalPin(a_Obj, 'D2', 0);
%writeDigitalPin(a_Obj, 'D4', 1);
%% Position des Boxs wird hier kopiert
BoxPos = mean(rectangle);
BmitteX = BoxPos(1);
BmitteY = BoxPos(2);
% Lese Die Position des Pan Servos, Regelkreis
posx= readPosition(panServo);
posx_deg = posx *360;
valx = BmitteX; % Mitte Punkt des ROI wert wird kopiert
if valx < screenmaxx/2 - incx
if posx < servomaxx_UpperLimit % Parameter umwandelung 0 bis 360 Gard ist in Matlab auf Sigmoid Funktion dargestellt (0 bis 1)
posx = posx + distancex/25
else posx = 0.5;
end
elseif valx > screenmaxx/2 +incx
if posx >= servomaxx_LowerLimit
posx = posx - distancex/25; % 100 ist der Passende Wert nach dem Fine tuning
else posx = 0.5; % Grenze uberschritten, Kamera auf Start Position zuerucksetze
end
end
% Redundanz, Arbeitsbereich des Servo Motor wird beschraenkt
if posx > 0.1 && posx <0.9
writePosition(panServo, posx)
end
if valx > screenmaxx/2 - incx || valx < screenmaxx/2 + incx
writeDigitalPin(a_Obj, 'D3', 0);
writeDigitalPin(a_Obj, 'D4', 1);
end
if valx < screenmaxx/2 - incx || valx > screenmaxx/2 + incx
writeDigitalPin(a_Obj, 'D3', 1);
writeDigitalPin(a_Obj, 'D4', 0);
end
%% Tilt Bewegung
posy= readPosition(tiltServo);
valy = BmitteY; % Mitte Punkt des ROI wert wird kopiert
if valy < screenmaxy/2 - incy
if posy < servomaxy_UpperLimit % Parameter umwandelung 0 bis 360 Gard ist in Matlab auf Sigmoid Funktion dargestellt (0 bis 1)
posy = posy + distancey/45;
else posy = 0.7; % Grenze uberschritten, Kamera auf Start Position zuerucksetzen
end
elseif valy > screenmaxy/2 +incy
if posy > servomaxy_LowerLimit
posy = posy - distancey/45; % 120 ist der Passende Wert nach dem Fine tuning
else posy = 0.7;
end
end
% Redundanz, Arbeitsbereich des Servo Motor wird beschraenkt
if posy > 0.4 && posy <0.8
writePosition(tiltServo, posy);
end
if valy > screenmaxy/2 - incy || valy < screenmaxy/2 + incy
writeDigitalPin(a_Obj, 'D3', 0);
writeDigitalPin(a_Obj, 'D4', 1);
end
if valy < screenmaxy/2 - incx || valy > screenmaxy/2 + incy
writeDigitalPin(a_Obj, 'D3', 1);
writeDigitalPin(a_Obj, 'D4', 0);
end
end
step(videoPlayer, video_Frame);
run_loop = isOpen(videoPlayer);
%pause(pause_time);
end
clear cam;
release(videoPlayer);
release(point_Tracker);
release(face_Detector);
Komponententest
servomotor bewegung testaufbau auf breadboard / kommunikation zwischen matlab und arduino / motorbewegung / Kameraauflösung (passenden auswahl der auflösung, verschiedene wurden ausprobiert) / Feintuning der Schrittweite der servomotoren bei zusammengebautem modell (abängig von der Bildverarbeitungsgeschwindigkeit des rechners) /
Ergebnis
Zusammenfassung
Lessons Learned
Projektunterlagen
Projektplan
Projektdurchführung
YouTube Video
In dem folgenden youtube-Video YouTube-Video wird eine Demonstration des Projekts Gesichtverfolgungskamera gezeigt. Die Aufnahme fand in der Hochschule Hamm-Lippstadt mit Genehmigung statt.
Weblinks
Literatur
→ zurück zur Übersicht: Kategorie:ProjekteET MTR BSE WS2022