Gesichtsverfolgungskamera

Abb. Werbeplakat für Projektmesse

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

Tabelle 1: Anforderungen an die Gesichtsverfolgungskamera

Nr.	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.
1.4	Zur Steuerung des Systems soll das Programm mit Simulink umgesetzt werden.
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 (Gesicht erkannt und zentriert: Grüne LED / Gesicht erkannt, nicht zentriert: Gelbe LED / Gesicht nicht erkannt: Rote LED).
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

Abb. 4: Darstellung eines Arduino UNO Mikrokontrollers

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

Abb. 5: Darstellung eines Servomotors des Typs MG90S

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

Abb. 6: Darstellung der 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

Abb. 7: Kennlinien LEDs verschiedener Farben (https://mezdata.de/ti-technologie/ea040_led/)

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. 8: CAD Ansicht Gehäuse

• 

  Abb. 9: CAD Ansicht Halter für Servomotoren

• 

  Abb. 10: CAD Ansicht Kamerastativ

• 

  Abb. 11: CAD Ansicht Webcamhalter

Montage

Die Grundplatte des Gehäuses (Abb. 8) 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.
Auf die Grundplatte wurde das Stativ aufgeschraubt. Auf dem Stativ wurde einer der Servomotoren mit einem Halter befestigt, um ab hier den gesamten oberen Teil des Modells Schwenkbar zu gestalten. Der Servomotor, der für die Schwenkbewegung verantwortlich ist wurde zusammen mit dem Servomotor der die Webcam neigt an dem Motorhalter montiert. Auch der Webcamhalter wurde mittels einer Welle, um neigbar gelagert zu sein, an dem Motorhalter angebracht. Bewegt wird die Konstruktion des Webcamhalters über einen Stab und eine Hebel, die an die Welle des zweiten Servomotors angeschlossen sind.

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.

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.

Abb. 9: Objectverfolgung Konzept Darstellung

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

Bevor die Bauteile miteinander verlötet wurden und das Gehäuse des Systems aufgebaut wurde, sind sowohl elektrische als auch mechanische Komponenten auf ihre Funktionalität und Passgenauigkeit überprüft worden. In den Folgenden Unterkapiteln werden die Arbeitsschritte beschrieben.

Elektrische Komponenten

Um die elektrischen Komponenten zu testen war ein Versuchsaufbau erforderlich. Für einige Bauteile reichte schon ein simpler Aufbau einer Schaltung auf einem Breadboard, für andere musste der Arduino UNO hinzugezogen werden.
Zunächst wurden die ohmschen Widerstände mit einem Multimeter in einer Widerstandsmessung auf ihren Wert kontrolliert und es wurde verglichen, ob die Abweichung innerhalb der zulässigen Toleranz liegt.

Im Anschluss daran wurde ein Versuch auf dem Breadboard aufgebaut, mit dem die LEDs unter Verwendung der zuvor getesteten Widerstände angesteuert wurden. Bei dem Versuchsaufbau auf dem Breadboard wurde ebenfalls der Spannungsbegrenzer auf seine Funktion getestet.

Die Servomotoren zu überprüfen erforderte ein einfaches Skript, den Arduino UNO und den zuvor getesteten Spannungsbegrenzer. Mit diesem wurde die Versorgungsspannung für die Servomotoren bereitgestellt. Das PWM Signal zur Ansteuerung dieser wurde über das Skript und den Arduino UNO ausgegeben. Mit dem Programm wurden die Motoren langsam zwischen ihren Anschlägen verfahren.

Die Webcam wurde lediglich über den USB Port mit einem Computer verbunden. Anschließend wurde kontrolliert ob Bilder und Videos in gewünschter Qualität aufgezeichnet werden können.

Mechanische Komponenten

Das Gehäuse, der Webcamhalter, der Halter für die Servomotoren und das Stativ wurden auf Maßhaltigkeit kontrolliert. Anschließend wurde die Passgenauigkeit der Teile überprüft, als das Modell probelhalber zusammen gesetzt wurde. Da alle mechanischen und elektrischen Komponenten den Anforderungen entsprachen wurde das Modell nach Schaltplan verkabelt und anschließend zusammengesetzt.

Tabelle 2: Erfüllte Anforderungen an die Gesichtsverfolgungskamera

Nr.	Anforderung	Anforderung erfüllt	Anforderung nicht erfüllt	Bemerkung
1	Allgemein
1.1	Die Kamera soll Gesichter erkennen und ein einmal erfasstes Gesicht so lange verfolgen, wie es sich im Sichtfeld aufhält.	X
1.2	Falls sich mehrere Gesichter im Sichtfeld aufhalten soll nur ein Gesicht erfasst und verfolgt werden.	X
1.3	Das System soll den aktuellen Status über LEDs darstellen.	X
1.4	Zur Steuerung des Systems soll das Programm mit Simulink umgesetzt werden.		X	Die Umsetzung mit Simulink war nicht möglich, da die Visiontoolbox nicht für Simulink zur Verfügung steht und somit die Auswertung der aufgenommenen Bilder nicht möglich war. Die Steuerung wurde stattdessen mit Matlab realisiert.
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.	X
2.2	Anhand der Position des erfassten Gesichts soll der Systemstatus ermittelt werden (Gesicht erkannt und zentriert / Gesicht erkannt, nicht zentriert / Gesicht nicht erkannt).	X
3	Ausgabe
3.1	Es soll permanent der Status über LEDs angezeigt werden (Gesicht erkannt und zentriert: Grüne LED / Gesicht erkannt, nicht zentriert: Gelbe LED / Gesicht nicht erkannt: Rote LED).	X
3.2	Die Servomotoren sollen über den Arduino UNO angesteuert werden und so immer versuchen ein erfasstes Gesicht zu zentrieren.	X

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.

Video 1: Gesichtverfolgungskamera im Einsatz

Literatur

---

→ zurück zur Übersicht: Kategorie:ProjekteET MTR BSE WS2022