FACULTEIT INDUSTRIELE INGENIEURSWETENSCHAPPEN CAMPUS DE NAYER
Categoriseren van personen op basis van leeftijd en geslacht
Bjorn HUYSMANS
Promotor:
Prof. Dr. Ir Toon Goedeme´
Masterproef ingediend tot het behalen van de graad van master of Science in de ¨ wetenschappen: Elektronica-ICT industriele Afstudeerrichting informatie- en communicatietechnieken
Academiejaar 2013 - 2014
FACULTEIT INDUSTRIELE INGENIEURSWETENSCHAPPEN CAMPUS DE NAYER
Categoriseren van personen op basis van leeftijd en geslacht
Bjorn HUYSMANS
Promotor:
Prof. Dr. Ir Toon Goedeme´
Masterproef ingediend tot het behalen van de graad van master of Science in de ¨ wetenschappen: Elektronica-ICT industriele Afstudeerrichting informatie- en communicatietechnieken
Academiejaar 2013 - 2014
c Copyright KU Leuven
Zonder voorafgaande schriftelijke toestemming van zowel de promotor(en) als de auteur(s) is over¨ nemen, kopieren, gebruiken of realiseren van deze uitgave of gedeelten ervan verboden. Voor aanvragen tot of informatie i.v.m. het overnemen en/of gebruik en/of realisatie van gedeelten uit deze publicatie, wend u tot KU Leuven campus De Nayer, Jan De Nayerlaan 5, B-2860 Sint-KatelijneWaver, +32-15-316944 of via e-mail
[email protected]. Voorafgaande schriftelijke toestemming van de promotor(en) is eveneens vereist voor het aanwenden van de in deze masterproef beschreven (originele) methoden, producten, schakelingen en programma’s voor industrieel of commercieel nut en voor de inzending van deze publicatie ter deelname aan wetenschappelijke prijzen of wedstrijden.
Dankwoord Vooraleer deze masterproef tot stand kon komen, heb ik het genoegen gehad met een aantal personen te mogen samenwerken alsook met het bedrijf Eavise. Mijn promotor Prof. Dr. Ir. Toon Goedeme´ wil ik hierbij bedanken voor de steun en het advies dat ik gekregen heb tijdens het uitwerken van deze masterproef. Steven Puttemans wil ik bedanken voor de hulp voor het vinden van de juiste info en de documentatie van OpenCV en voor het zoeken in reeds bestaande software naar fouten. Floris De Smedt bedank ik voor de hulp bij het opzetten van libccv . Ook zonder de hulp van familieleden, vrienden en buren zou deze masterproef nooit enig resultaat opgeleverd hebben. Hierbij wil ik deze bedanken om er voor mij te zijn en klaar te staan voor de verschillende testsessies, fotoshoots en video-opnames.
ix
Abstract Deze thesis is een project van de onderzoeksgroep EAVISE en heeft als doel het ontwikkelen van een programma dat de reclame-industrie mogelijk maakt om reclame weer te geven afhankelijk van de aanwezige doelgroep. Dit wilt zeggen dat door middel van een camera vlak bij het reclamebord, mensen zullen kunnen gedetecteerd worden en aan elk van deze personen een groep zal toegekend worden. Hoe deze categorisatie moet gebeuren en op basis van welke kenmerken, zullen we in deze thesis onderzoeken. Dit programma zal gebruikt kunnen worden door bedrijven die zich bezighouden met het presenteren van reclame indien zij hieraan nog extra software koppelen voor de weergave van de reclame. De classificatie waarop wij ons gaan richten is op basis van de leeftijd en het geslacht van een persoon. Door middel van een camera zullen we informatie uit de omgeving verzamelen, hierop de personen detecteren en deze classificeren. Om deze beelden te verwerken, maken we gebruik van het programma OpenCV. Dit is een gratis bibliotheek waarin gecodeerd kan worden in C++. Deze bevat reeds een personendetector en vele functies om onze eigen detectoren en classifier te trainen. Ons algoritme is opgedeeld in zes onderdelen. Allereerst zullen we personen detecteren in de ontvangen beelden. Vervolgens zullen we het gezicht van deze personen detecteren. Omdat het systeem real-time moet presteren, is het belangrijk de verwerkingssnelheid optimaal te houden. We kunnen de gezichtsdetectie versnellen door enkel het bovenste deel van de personen, door de persoonsdetector gedetecteerd, door te geven aan de gezichtsdetector in plaats van de gehele afbeelding. Wanneer een gezicht gedetecteerd is, kunnen we hiermee het geslacht bepalen. Dit zullen we doen door middel van een Haar-detector of LBP-detector die getraind is op mannengezichten. Aangezien we reeds weten dat het een persoon is en er een gezicht aanwezig is, kunnen we ook besluiten dat indien het geen man is, het een vrouw moet zijn. De leeftijd van de personen zullen we bepalen afhankelijk van hun geslacht en lengte. Deze twee kenmerken kunnen we koppelen aan statistieken omtrent de gemiddelde lengte op bepaalde leeftijden. Het resultaat van deze categorisatie is beperkt. We kunnen namelijk een slechte opdeling maken in leeftijden omdat we ons enkel baseren op de lengte. Oudere personen (50+) kunnen we niet aparte categoriseren omdat we hiervoor te weinig informatie hebben. De geslachtsdetectie werkt enorm vlot, met de beperking dat het gezicht van de aanwezige personen frontaal in beeld moet komen. De lengtebepaling is vrij onstabiel en de oorzaak ligt bij de personendetector. De grootte van de detecties verandert continu en aangezien we ons hierop baseren, is er dus enorm veel ruis op de berekende lengte. Toch werkt het systeem volledig real-time en is het een enorm flexibel systeem waarbij de gebruiker verscheidene parameters kan aanpassen zodat het algoritme werkt naar zijn normen.
xi
Abstract (English) This thesis is a project by the research group EAVISE and its purpose is to develop software which gives publishing companies the ability to show ads adapted to the people around their billboards. By using a camera located near the billboard, persons can be detected and categorised. How this categorisation happens and what features are used to do so, shall be researched in this thesis. This program can be used by companies whose business is to make ads if they use or create additional software which is linked to the result of our program. The classification we are going to implement is based on the gender and age of the persons on the images. By using one camera, we will be able to gather information of the surroundings. With this information, which are images, we will detect persons and categorise them. To process these images, we will use software called OpenCV. This is a free vision library coded in C++. This library already contains a pedestrian-detector and many other functions to train our own detectors and classifiers. Our algorithm is divided into six parts. First, we’ll detect pedestrians in the captured images. afterwards, we will detect the faces of those pedestrians Because our system has to work in realtime, we have to consider any speed improvements. A nice speed improvement is to only send the upper part of the pedestrian image to the face-detector as its detection-speed will be increased. When a face is detected, this face is sent to the gender-detector. This detector detects male faces based on Haar- or LBP-techniques. Because we already know it is a person and the face of this person is aimed at the camera, we can conclude that if the face is not male, the face has to be female. The age of the pedestrian will be estimated based on the length and the gender of the pedestrian. These two features of persons can be linked to statistics about average length on certain ages which gives us the ability to classify the pedestrian. The results of this categorisation is limited. Because our age estimation is solely based on the length of the pedestrian, we can only divide them into a limited number of categories. Elderly pedestrians (50+) won’t be divided into a separate group because of the lack of information. The gender-detection performs very good with the limitation that the faces have to be aimed at the camera. Otherwise, no gender can be determined. The length estimation is quite unstable. This is due to the fact that the size of the pedestrian-detection varies a lot which results in a lot of noise on the output. Yet, the system performs in real-time and it is very flexible. The user of the software is able to adapt various parameters so the algorithm works to his likings.
xiii
Short Summary In this thesis, we are going to research the ability of categorising pedestrians based on their gender and age. The gender-detection makes use of the face of the pedestrians while the age-classification is based on the gender and the length of the pedestrian. We will use OpenCV as our software to develop the gender-detector while using the pedestrian- and face-detectors already included in OpenCV.
Background EAVISE, which stands for Embedded Artificially intelligent VISion Engineering, is a multidisciplinary research group based at Campus De Nayer in Sint-Katelijne-Waver focusing on applications of advanced computer vision and artificial intelligence. The research goal of EAVISE is applying stateof-the-art computer vision techniques as a solution for industry-specific vision problems. EAVISE figured out that companies advertising their product are wasting their money when their ads are shown to the wrong target group. For example when people walk past a billboard in the shopping mall. If a system is developed which is able to categorise the pedestrians, ads could be shown specifically for a target category. In this thesis, a system that categorises pedestrians real-time and based on their age and gender is proposed.
The algorithm The algorithm we implemented consists of six parts which we execute directly after each other. This implementation is called a cascade and is widely used. It also gives our algorithm the flexibility it needs. Whenever an additional step is necessary, one can add it to the cascade without interfering the other steps. The same can be applied when removing a step, besides from the necessary steps which could be changed for other methods. To develop such a system, we are in need of software. Even though we would like to use libccv because of its performance, we will be using OpenCV as this vision-library has a lot of documentation and we were not able to set-up the libccv environment correctly. The first part of our algorithm is the detection of pedestrians in the given image. The pedestriandetector we use is packed within the free library of OpenCV. As one of our requirements is a real-time classification, we will cut out the detected pedestrians from the original image and give the upper part of this image to the next step: the face-detector. By doing this, the face-detector has a smaller area to detect faces which will be a huge speed improvement. The full pedestrian image will be used for the determining the length. The face-detector, also available in the OpenCV library, will give us the information whether we are able to classify the pedestrian or not. If a face xv
xvi
is detected, we can continue our own gender-detector and age-determination part. The way the detectors pass their information to each other is visualised in figure 1
Figure 1: Visualisation of the information sent to the different detectors with a) pedestrian-detector, b) facedetector and c) gender-detector
In this thesis, we trained several gender-detectors based on the face of the pedestrians, each with another technique. We used Haar-features, LBP-features and HOG-features in our training and compared the results in terms of speed and accuracy. After our gender is determined, we have to determine the actual length of the pedestrian. With enough information from the cameras, there would be no problem. However, we would like to use only one camera which makes this a little bit more difficult. To calculate the real length of a pedestrian from a single camera, a few parameters about the environment have to be known. That is why we created a calibration function. In this function, the camera has to be set-up and the user has to give some input to the system which includes the distance from the camera till the bottom of the actual frame (image). The distance from the camera till the endpoint of the ground on the frame and where those points are located on the frame itself (pixel-wise) are also needed. With these values, the camera-constant is calculated which is needed to estimate the length of a pedestrian on an image from the camera. The age classification is a combination of both gender and length. When we use these two characteristics, we are able to classify the pedestrians by using the average length at certain ages. We have now categorised the pedestrians based on their gender and age.
Results The results of our approach were satisfactory, but not exceptional. We do have some additional requirements because we chose to classify them by using their face and length. First of all, the system works real-time with multiple people walking in front of the camera. However, the pedestrians’ body have to be fully visible on the image to be able to classify them. Also their face should be facing towards the camera. Another shortcoming of this approach is that when our age-classification
xvii
is only based on the length and gender, we do not have enough information to determine many age categories. Pedestrians who are older than 12 years can not be further categorised without additional information. While the gender-detection is quite stable, our length-determination is not. This is because the calculated length is based on the size of the pedestrian-detection. This detection varies quite a lot and so does our length. However, when the average length is calculated, the result equalises the actual length. Though our system has some shortcomings, it can be easily extended or adapted to achieve better results or to add additional categories. The following images show our final results.
Figure 2: Full algorithm on a boy and a man
Figure 3: Full algorithm on a woman
Inhoudsopgave 1 Inleiding 1.1 Algemene probleemstelling
1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
1.2 Organisatie van deze tekst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
2 Situering en doelstelling
3
2.1 Situering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2.2 Doelstelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
3 Literatuurstudie
5
3.1 Introductie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
3.2 Technieken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
3.2.1 Haar-like Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
3.2.2 Histogram of Oriented Gradients . . . . . . . . . . . . . . . . . . . . . . . .
7
3.2.3 Local Features with Implicit Shape Model . . . . . . . . . . . . . . . . . . .
9
3.2.4 Local Binary Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
´ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.5 Dollar
9
3.2.6 Support Vector Machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 3.3 Leeftijdsbepaling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 3.3.1 Facial Age Paterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 3.3.2 Skin Wrinkle Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.4 Geslachtsbepaling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.4.1 Local Binary Patterns en Support Vector Machines . . . . . . . . . . . . . . 14 3.4.2 Gender Recognition from Body . . . . . . . . . . . . . . . . . . . . . . . . . 15 3.5 Platformen en omgevingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 3.5.1 OpenCV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 3.5.2 Libccv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 3.6 Evaluatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 3.7 Conclusie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 4 Uitwerking
19
4.1 Algemene Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 xix
xx
INHOUDSOPGAVE
4.1.1 Geslachtsbepaling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 4.1.2 Leeftijdsbepaling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 4.1.3 Conclusie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 4.2 Programmeeromgeving
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.3 Voorbereiding van de beelden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 4.4 Persoonsdetectie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 4.4.1 Haar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 4.4.2 HOG
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.4.3 Evaluatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 4.4.4 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 4.5 Gezichtsdetectie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 4.5.1 Haar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 4.5.2 LBP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 4.5.3 Evaluatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 4.5.4 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 4.6 Geslachtsclassificatie 4.6.1 Datasets
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.6.2 Cascade training . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4.6.3 Evaluatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 4.6.4 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 4.7 Lengtebepaling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 ´ en ´ camera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 4.7.1 E 4.7.2 Kalibratie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.8 Leeftijdsbepaling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 5 Resultaten
33
5.1 Algemene performantie
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.2 Nauwkeurigheid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 5.3 Totale algoritme 6 Besluit
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 37
6.1 Toekomstig werk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 A Programma code
41
Lijst van figuren 1
Visualisation of the information sent to the different detectors with a) pedestriandetector, b) face-detector and c) gender-detector . . . . . . . . . . . . . . . . . . . xvi
2
Full algorithm on a boy and a man . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii
3
Full algorithm on a woman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii
1.1 Elektronisch reclamebord waarbij doelgerichte reclame wordt afgebeeld . . . . . . .
1
3.1 Soorten features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
3.2 Feature representatie bij gezichtsdetectie . . . . . . . . . . . . . . . . . . . . . . .
7
3.3 Star Model, (a) Toepassing van enkel de hoofdfilter, (b) Hogere resolutie deeltjes filters en (c) een spatiaal model als relatie tot de hoofdfilter . . . . . . . . . . . . . .
8
3.4 Methode van grenswaarden bij LBP en drie uitbreidingen: a) basis LBP, b) circulaire (8,1) regio, circulaire (8,2) regio en d) circulaire (8,3) regio . . . . . . . . . . . . . . 10 ´ combinatie van verschillende channels 3.5 Dollars
. . . . . . . . . . . . . . . . . . . . 10
3.6 SVM techniek met a) verschillende mogelijke scheidingslijnen en b) optimale scheidingslijn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 3.7 Evolutie van het ouder worden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 3.8 Rimpelmap. Bevat de regio’s waarin naar rimpels gezocht moet worden . . . . . . . 13 3.9 Resultaat van edgedetectie door middel van snakes
. . . . . . . . . . . . . . . . . 14
3.10 LBP methode op gezichten. (a) Preprocessed faces, (b) Bijhorende LBP faces, (c) Bijhorende 5x5 rooster LBP faces . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 3.11 Voorstelling van de verschillende technieken. (a) originele afbeelding, (b) edge map, (c) Histogram of Oriented Gradients (HOG) . . . . . . . . . . . . . . . . . . . . . . 15 3.12 Resultaten van de verschillende technieken op verschillende datasets bij het detecteren van personen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 4.1 Flow van het algoritme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 4.2 Grafische voorstelling van de detectoren in het algoritme met a) persoonsdetectie, b) gezichtsdetectie en c) geslachtsbepaling . . . . . . . . . . . . . . . . . . . . . . 21 4.3 Histogram van een afbeelding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 4.4 Histogram equalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 4.5 Visualisatie van de persoonsdetectie met rechts de uitgeknipte persoon . . . . . . . 25 4.6 Visualisatie van de gezichtsdetectie met rechts het uitgeknipte gezicht . . . . . . . . 26 xxi
xxii
LIJST VAN FIGUREN
4.7 Parameters nodig voor de lengtebepaling . . . . . . . . . . . . . . . . . . . . . . . 29 4.8 Camerastandpunt bij lengtebepaling . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.9 Groeicurve van jongens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 4.10 Groeicurve van meisjes 5.1 Foutive geslachtsdetectie
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.2 Lengte- en leeftijdsbepaling van een jongen . . . . . . . . . . . . . . . . . . . . . . 35 5.3 Lengte- en leeftijdsbepaling van een man . . . . . . . . . . . . . . . . . . . . . . . 35 5.4 Resultaat van het algoritme op een man . . . . . . . . . . . . . . . . . . . . . . . . 36 5.5 Resultaat van het algoritme op een vrouw . . . . . . . . . . . . . . . . . . . . . . . 36
Verklarende lijst van afkortingen en symbolen Detector Software die objecten detecteert in beelden Classifier Software die gedetecteerde objecten categoriseert CPU Central Processing Unit is hardware dat de basis instructies van een computerprogramma uitvoert GPU Graphical Processing Unit is hardware dat specifiek grafische bewerkingen uitvoert CUDA Compute Unified Device Architecture is GPU-technologie die het mogelijk maakt om algoritmes uit te voeren op de GPU LTS Long Term Support is software waarvoor lange tijd hulp (support) zal worden aangeboden LBP Local Binary Patterns is een techniek om features (kenmerken) uit een afbeelding te halen en voor te stellen
xxiii
Hoofdstuk 1
Inleiding 1.1
Algemene probleemstelling
Reclame, we worden er regelmatig mee geconfronteerd: op de bus, op het internet, op de televisie, in het winkelcentrum,... ] Producenten weten reeds lange tijd dat producten nu eenmaal vaak beter verkopen als ze extra in de verf worden gezet. Een miljoenenbusiness. En hoewel de publishers proberen om de juiste locaties en tijdstippen te zoeken voor bepaalde reclame, toch zal veel van deze reclame zijn doelgroep missen. Reclame is meestal bedoeld voor een specifieke groep van personen. De huidige manier van reclame maken, kan hier moeilijk op inspelen. Reclame tonen die afhankelijk is van de doelgroep die zich het meest profileert in de omgeving van het reclamebord, dat zou de producenten enorm wat geld besparen. Dit willen we in deze thesis verder uitdiepen. Als we in staat zijn de mensen in de nabije omgeving te detecteren via een camera en deze personen te classificeren, kunnen we bepalen welke doelgroep het meest aanwezig is op dat moment. Dit gekoppeld aan software dat, afhankelijk van het resultaat, specifieke reclame kan weergeven, zorgt ervoor dat de reclame op het juiste moment en dus aan de juiste personen wordt getoond. Natuurlijk kunnen we dit moeilijk toepassen bij de mensen thuis. Daarom zullen we ons baseren op een opstelling waarbij er een camera vlak bij een elektronisch reclamebord gepositioneerd wordt, waarvan we beelden zullen ontvangen die we vervolgens zullen verwerken.
Figuur 1.1: Elektronisch reclamebord waarbij doelgerichte reclame wordt afgebeeld
1
2
1 Inleiding
Het resultaat van de verwerking zou de personen moeten classificeren op basis van hun leeftijd en hun geslacht. Hiermee kunnen we de reclame- industrie helpen om geld te besparen en het voor de mensen aangenamer te maken om naar reclame te kijken die specifiek voor hen bedoeld is.
1.2
Organisatie van deze tekst
Deze masterthesis is als volgt opgebouwd. We beginnen met een situering en een duidelijke bepaling van onze doelstelling in hoofdstuk 2. In hoofdstuk 3 zal een studie gemaakt worden rond het detecteren van personen, hoe we classificaties kunnen uitvoeren, welke de beste technieken zijn om dit te doen en waarom. We zullen ook een studie doen naar hoe we de leeftijd en het geslacht van personen kunnen bepalen. In hoofdstuk 4 komt de uitgewerkte methode aan bod met hierin de gebruikte datasets en aangeleerde classifiers. Hoe ons algoritme tot stand gekomen is, het waarom en een korte evaluatie zal hier uitgelegd worden. Hoofdstuk 5 zal gaan over de resultaten van de verschillende onderdelen van ons algoritme. We eindigen met hoofdstuk 6 met het besluit en eventuele opmerkingen omtrent ons algoritme. Hierin zullen ook eventuele verbeteringen voor komende studies te vinden zijn. In de bijlage vindt u een DVD met de sourcecode van de verschillende geschreven programma’s, gebruikt beeldmateriaal en een digitale versie van deze thesis.
Hoofdstuk 2
Situering en doelstelling 2.1
Situering
¨ intelligentie gesitueerd op Eavise, een onderzoeksgroep gericht op computer vision en artificiele Campus De Nayer in Sint-Katelijne-Waver, is er van overtuigd dat een systeem, waarbij personen gecategoriseerd worden op basis van geslacht en leeftijd, kant-en-klaar beschikbaar moet zijn voor de reclame-industrie. EAVISE staat voor Embedded Artificially Intelligent Vision Engineering en behoort tot de onderzoeksgroep van de KU Leuven en de Thomas More Technische Universiteit. ¨ onderdeel Het visie onderdeel van hun onderzoeksgroep is ge¨ıntegreerd met VISICS, het artificiele met DTAI. Ze hebben reeds veel onderzoek gedaan naar het implementeren van beeldverwerkende software en algoritmes. Aangezien ze hierdoor al heel wat technieken en algoritmes bezitten, willen ze een methode uitwerken en het nodige doen, zodat er gerichtere reclame kan getoond worden en dus minder geld verloren gaat in de reclame-industrie.
2.2
Doelstelling
Mensen komen in alle maten en gewichten voor. Gelukkig zijn er ons reeds velen voorgegaan in het domein van het detecteren van personen in beelden, maar het bepalen van de leeftijd en het geslacht is een heel andere opgave. We zullen ons enkele doelen voor ogen moeten stellen voordat we kunnen starten met het zoeken naar mogelijke oplossingen. Onze doelstelling is het maken van een flexibel en real-time systeem dat personen classificeert ´ camera. op basis van hun leeftijd en geslacht en dit met slechts e´ en Vereisten:
• Categorisatie moet gebeuren op basis van leeftijd en geslacht • Reclame moet real-time aangepast worden, dus de classificatie moet real-time functioneren ´ camera • Maximaal gebruik van e´ en Met deze vereisten in het achterhoofd, kunnen we deelonderzoeksvragen opstellen op basis hiervan.
3
4
2 Situering en doelstelling
Leeftijd en geslacht
• Op basis van welke kenmerken kunnen we simpel en snel de leeftijd bepalen? • Zijn er specifieke vereisten voor de positie en/of de stand van de persoon voor de classificatie?
• Wat is een snelle manier om het geslacht te bepalen? • Welke techniek levert de beste prestaties? Real-time
• Is het mogelijk zo een systeem real-time te maken? Camera ´ camera? • Is het mogelijk zo’n classificatie uit te voeren met slechts e´ en
• Kunnen we hiermee een flexibel en instelbaar programma maken? Nu onze onderzoeksvraag en deelonderzoeksvragen vast liggen, kunnen we starten aan het uitzoeken van een algoritme. We zullen onderzoeken welke technieken reeds getest zijn en wat de resultaten van deze studies waren. We doen dit in hoofdstuk 3: de literatuurstudie.
Hoofdstuk 3
Literatuurstudie 3.1
Introductie
In deze literatuurstudie stellen we ons de vraag hoe we mensen kunnen detecteren in een omgeving en hoe we deze mensen kunnen categoriseren. Indien men dergelijk systeem wilt ontwikkelen, is een grondige voorafgaande studie noodzakelijk. Ons doel is om een algoritme te bedenken dat het mogelijk maakt om via een camera, dat zich vlakbij een digitaal reclamebord bevindt, personen te detecteren en deze kan indelen op basis van hun leeftijd en geslacht. Om dit te bereiken, moeten we eerst onderzoeken wat de reeds verschillende onderzochte technieken zijn om dit soort detecties uit te voeren en hoe we de algemene flow van ons algoritme moeten opstellen. De daarop volgende onderdelen van deze studie zullen mogelijke onderdelen van ons algoritme uitleggen. Zo staan er in 3.2 de mogelijke technieken om detecties uit te voeren, bijvoorbeeld voor de persoonsdetectie. Onderdeel 3.3 legt de mogelijkheden uit om de leeftijd van personen te bepalen en op welke kenmerken deze steunen. De mogelijkheden om het geslacht van personen te bepalen door middel van beeldverwerking, zijn uitgelegd in 3.4. In 3.5, het laatste onderdeel van deze literatuurstudie, bekijken we mogelijke platformen en besturingssystemen waarop we beeldverwerkendesoftware kunnen ontwikkelen.
3.2
Technieken
Aan de hand van onze onderzoeksvragen kunnen we nu een studie uitvoeren naar mogelijke technieken om objecten in een beeld te detecteren of om classificaties uit te voeren. Afhankelijk van de techniek zullen we resultaten verkrijgen op performantie- en nauwkeurigheidsvlak. Deze zullen beslissend zijn om te bepalen welke techniek toegepast zal worden in ons onderzoek.
3.2.1
Haar-like Features
Haar-like features is een techniek waarbij het systeem gebruik maakt van features of kenmerken in een afbeelding in plaats van te werken met de pixelintensiteit. Ook in de studie van Papageorgiou et al. (1998) worden deze features berekend door afgeleiden van Haar Basis functies. Om de snelheid van deze bepaling te verhogen, en ook toe te kunnen passen op verschillende schalen, wordt deze berekening niet uitgevoerd op de oorspronkelijke afbeelding, maar op de Integral Image. De integral image is een voorstelling van de oorspronkelijke afbeelding. Deze is op positie x,y gelijk 5
6
3 Literatuurstudie
aan de som van de pixels boven en links van x,y met x en y inclusief:
ii(x, y) =
∑
i(x0 , y0 )
(3.1)
x0 ≤x,y0 ≤y
waarbij ii(x,y) de integral image is en i(x,y) de originele afbeelding. Eens deze Integral image berekend is, kan elke soort Haar-like feature bepaald worden op elke schaal en in een constante tijd. De techniek van Viola and Jones (2001) maakt gebruik van 3 soorten features:
• Two-rectangular feature • Three-rectangular feature • Four-rectangular feature De two-rectangular feature maakt gebruik van twee rechthoeken. Het resultaat is het verschil van de som van de pixels van de twee rechthoeken. Beide rechthoeken hebben dezelfde grootte en vorm. De three-rectangular feature gebruikt drie rechthoeken. Hierbij is het resultaat gelijk aan het verschil van de som van de twee buitenste rechthoeken met de binnenste rechthoek. De fourrectangular feature heeft vier rechthoeken en het resultaat is het verschil tussen de som van de twee diagonale paren rechthoeken. De resultaten zijn te zien in fig 3.1.
Figuur 3.1: Soorten features
Deze rechthoekige features zijn weliswaar vrij primitief ten opzichte van andere bestaande alternatieven. Rechthoekige features zijn gevoelig voor randen, balken of andere eenvoudige structuren ¨ maar niet voor details. Ook wanneer de orientatie van belang is, zijn de rechthoekige features geen goede keuze. Zo zijn ze voor gezichtsdetectie enkel handig wanneer het gezicht zich recht voor de camera bevindt, zoals te zien is op figuur 3.2. Toch blijft deze techniek sterk. Door zijn enorm ¨ rekenwerk, kan deze techniek goed getraind worden en compenseert deze zo zijn mindere efficient flexibiliteit. De techniek van Viola and Jones (2001) is al lange tijd bekend en er is een hele reeks aan implementatie mogelijkheden beschikbaar. Er zijn zowel algoritmes beschikbaar op de CPU als op de GPU en dit in verschillende programmeertalen (C++, Cuda,...). Dit is een bijzonder groot voordeel
3 Literatuurstudie
7
Figuur 3.2: Feature representatie bij gezichtsdetectie
aangezien er velen ons al voor gegaan zijn en er dus verschillende hulpmiddelen zijn voor de implementatie. Via dit principe zijn er een aantal persoons- en gezichtsdetectoren beschikbaar. Het is een techniek dat veel gebruikt wordt voor gezichtsdetectie. We kunnen hieruit besluiten dat haar-features een oude techniek is die wel real-time mogelijkheden biedt, doch bestaan er al andere, betere en snellere detectietechnieken. Niettemin kunnen we de beschikbare detectoren gebruiken.
3.2.2
Histogram of Oriented Gradients
HOG of Histogram of Oriented Gradients haalt features uit een afbeelding door te zoeken naar de overgangen tussen pixels. Deze overgangen kunnen te maken hebben met de intensiteit van de pixel, maar ook door een verandering van kleur en werkt dus pixelgewijs. Als we de afbeelding verdelen in kleinere delen of cellen, kunnen we door middel van een mask de richting van de veran´ dering zoeken. De optredende veranderingen kunnen we bijhouden in een nieuwe afbeelding, e´ en die een voorstelling weergeeft van de originele afbeelding. Het resultaat kunnen we vergelijken met eerder aangeleerde voorstellingen en hieruit kunnen we het object op de afbeelding categoriseren. De techniek van een mask over de afbeelding schuiven, noemen we de sliding window approach. De detector van Dalal and Triggs (2005) werkt via deze methode en maakt gebruik van een enkele filter gebaseerd op het HOG algoritme. Door aan deze detector een afbeelding te geven, een positie in deze afbeelding en een schaal, kunnen we bepalen of het object tot een bepaalde categorie
8
3 Literatuurstudie
behoort of niet en dit aan de hand van een score. De score kon als volgt berekend worden:
β.φ(x)
(3.2)
Hierbij is β de filter, x is de afbeelding met een specifieke plaats en schaal en φ(x) is een feature vector. Felzenszwalb (2010) innoveerde deze techniek door gebruik te maken van een star-structured part-based model dat voortkomt uit een root filter of hoofdfilter (die vergelijkbaar is met de DallalTriggs filter) met hier bovenop een verzameling van deeltjesfilters en vervormingsmodellen. De resulterende score in deze techniek is de score van de hoofdfilter opgeteld bij de som van de maxima van de deeltjesfilters minus een vervormingkost. Deze vervormingskost is de afwijking van de deeltjes ten opzichte van hun ideale positie. De score van de hoofdfilter en deeltjesfilter zijn beide het product van een filter, bestaande uit een set van gewichten, en een subwindow van de afbeelding. Wanneer meerdere delen in een afbeelding gebruikt worden, noemt men dit een star model zoals te zien op figuur 3.3.
Figuur 3.3: Star Model, (a) Toepassing van enkel de hoofdfilter, (b) Hogere resolutie deeltjes filters en (c) een spatiaal model als relatie tot de hoofdfilter
Dankzij deze aanpak heeft de techniek nog een veel betere detectiegraad. Indien we zelfs een combinatie van stermodellen maken, kunnen we deze detecteren en hieraan een andere categorie toewijzen. De implementatiemogelijkheden van deze techniek zijn niet zo uitgebreid als andere technieken. Hoewel dit een sterke techniek is en er reeds enkele implementatiemogelijkheden zijn, is de implementatie niet zo vanzelfsprekend. Mogelijke implementaties bevinden zich op het ccv of het OpenCV platform.
3 Literatuurstudie
9
Aangezien wij personen willen categoriseren, zal deze techniek al mogelijk in aanmerking komen. Door zijn sterke detectiegraad en gebruik van vervormingsmodellen, is HOG reeds een goede kandidaat. Voor de detectie van gezichten is dit een techniek die minder gebruikt wordt.
3.2.3
Local Features with Implicit Shape Model
Deze techniek steunt op 2 principes, namelijk een Codebook of Local Appearances en een Implicit Shape Model. Het eerste bevat informatie over welke lokale structuren zich kunnen bevinden op modellen van de te zoeken categorie. Het tweede bepaalt waar op het object deze structuren mogen voorkomen. Door deze aanpak worden geen expliciete modellen aangemaakt maar wordt er bepaald of iets toegestaan is. Hierdoor is deze techniek enorm flexibel en zijn er heel wat minder trainingsmodellen nodig om mogelijke objectvoorkomens aan te leren. Een ISM voor een bepaalde objectencategorie bevat een verzameling van mogelijke lokale kenmerken die typisch zijn voor de gegeven objectencategorie en een mogelijke verdelingsgraad die bepaalt waar elk lokaal kenmerk (Code book entry) mag gevonden worden. Een voorwaarde die gesteld wordt, is dat deze verdelingsgraad onafhankelijk bepaald is voor elke structuur. De tweede voorwaarde is dat deze verdelingsgraad bepaald is zonder parameters. Hierdoor is dit geen wiskundige verdeling zoals bij vele andere technieken, maar een verdeling die bepaald is door de training wat veel preciezer is. De manier waarop het codebook gegenereerd wordt, rust op het werk van Agarwal et al. (2004). Implementatiemogelijkheden van deze techniek zijn enorm beperkt. Er is weinig tot geen gemakkelijk implementeerbare code beschikbaar.
3.2.4
Local Binary Patterns
Local Binary Patterns, of LBP, is een techniek ontwikkeld door Ojala et al. (2002) en is een zeer sterke techniek als feature beschrijving. De techniek hierachter maakt gebruik van de grenswaarde van pixels van een afbeelding in een 3x3 regio. Hierbij wordt de waarde van de centrale pixel als grenswaarde gebruikt en het resultaat van de vergelijking met deze grenswaarde is een binair getal. ´ staat voor een getal groter of gelijk aan de grenswaarde, een nul voor een waarde kleiner. Een e´ en Dit resultaat wordt vervolgens in een reeks omgezet met de rechterbovenhoek van de 3x3 matrix als start. Een voorbeeld van deze grenswaardetechniek is te zien op figuur 3.4. Een groot nadeel van deze techniek is de kleine regio waardoor grote structuren in een afbeelding, wat eerder dominante features zouden zijn, niet voorgesteld zullen worden. Dit kan verholpen worden door gebruik te maken van grotere regio’s, wat ook door Ojala et al. (2002) bestudeerd is. Deze uitbreiding maakt gebruik van circulaire regio’s en billineaire interpolatie van de pixelwaarden. Hiermee is het mogelijk te kiezen hoe groot de straal van de cirkel is en dus hoeveel pixels zich in de regio bevinden. Ook op figuur 3.4 is hiervan een voorstelling gemaakt.
3.2.5
´ Dollar
´ et al. (2009) maakt gebruik van een combinatie van vorige opgenoemde technieken om Dollar zodanig een betere detectiegraad te kunnen garanderen. Eerst zal hij verschillende afbeeldingskanalen berekenen op een zowel lineaire als non-lineaire manier. Een afbeeldingskanaal is een kopie van de originele afbeelding waarbij de resulterende pixels berekend worden volgens een bepaalde formule bijvoorbeeld het inverse. Vervolgens komt de extractie van de features aan de beurt. Dit
10
3 Literatuurstudie
Figuur 3.4: Methode van grenswaarden bij LBP en drie uitbreidingen: a) basis LBP, b) circulaire (8,1) regio, circulaire (8,2) regio en d) circulaire (8,3) regio
gebeurt door gebruik te maken van sommen over lokale rechthoekige regio’s. De features komen ¨ zowel van Haar-like wavelets als lokale histogrammen waarbij alle sommen op de meest efficiente manier berekend worden via de integral image. Deze features noemen we integral channel features. Integral channel features combineren de rijkheid en diversiteit aan informatie die te verkrijgen is uit ¨ de afbeeldingskanalen, met de rekenefficientie die de detectiemehode van Viola and Jones (2001) biedt. Een voorbeeld van de verschillende kanalen is te zien in figuur 3.5.
´ combinatie van verschillende channels Figuur 3.5: Dollars
Een combinatie van oudere technieken zal qua detectiegraad en snelheid altijd een verbetering zijn. Deze techniek lijkt dan ook het meest belovend om een real-time detectie-algoritme te maken dat personen kan categoriseren. Op basis van deze techniek zijn er slechts weinig bestaande detectors voor personen of gezichten. We kunnen deze techniek dus gebruiken voor het bepalen van het geslacht. ´ techniek kent ook verschillende implementatiemogelijkheden. Zo is er een implementatie Dolars ´ de beste in ccv en in OpenCV. Beide implementaties zijn enorm sterk maar er kan er maar e´ en zijn. Het blijkt dat ccv een snellere implementatiemethode is dan OpenCV en de nauwkeurigheid ligt ook iets wat hoger. Dit zal een doorslaggevende factor zijn.
3.2.6
Support Vector Machines
Support Vector Machines, ofwel SVM, is een algoritme voor het aanleren van patroonclassificatie dat door Vapnik (1995) bedacht is. Door het uitzetten van de featurevoorstellingen in een tweedimensionaal vlak, is het mogelijk te zoeken naar een lijn die een scheiding maakt tussen de twee soorten featurevoorstellingen (wanneer we willen classificeren in twee groepen). Uiteraard zijn er meerdere scheidingslijnen mogelijk, zoals figuur 3.6 voorgesteld is.
3 Literatuurstudie
11
De vraag blijft welke scheidingslijn nu de beste is. We kunnen hier intu¨ıtief een criterium rond stellen: Een scheidingslijn is slecht wanneer het zich te kort bij de punten bevindt en dit omdat bij kleine aanpassing van de feature (of dus van de afbeelding) het object niet juist geclassificeerd zal worden. De meest optimale scheidingslijn bevindt zich het verst van alle punten. Het algoritme zal dus de grootste minimumafstand zoeken tussen de punten van de verschillende groepen (figuur 3.6). Deze afstand wordt in SVM-termen de margin genoemd.
Figuur 3.6: SVM techniek met a) verschillende mogelijke scheidingslijnen en b) optimale scheidingslijn
Wanneer een nieuwe afbeelding geclassificeerd wordt, zullen we eerst een featurevoorstelling maken en deze dan tegen de SVM testen. Afhankelijk van waar het nieuwe punt komt te liggen, ´ van de aangeleerde categorieen. ¨ behoort deze tot e´ en
3.3
Leeftijdsbepaling
De leeftijd van een persoon in een beeld kunnen we op verschillende manieren bepalen. Enkele methodes gevonden in de literatuur komen hier aan bod waardoor we in 4.1 kunnen concluderen welke techniek wij zullen hanteren.
3.3.1
Facial Age Paterns
In de studie van Geng et al. (2006) is er getracht de leeftijd van personen te bepalen door middel van de AGES (AGing pattErn Subspace) methode. Het basis idee van deze techniek houdt in dat het ouder worden van personen in bepaalde patronen gegoten kan worden, vooral wanneer men zich specifiek op het gezicht concentreert. Wanneer deze patronen in een computermodel ge¨ıntegreerd worden, is het mogelijk om een nog niet geclassificeerd gezicht te projecteren in het patroon waarmee dit gezicht het best mee gereconstrueerd wordt. De positie in dit patroon bepaalt dan de leeftijd van dit gezicht. Eerst zal de evolutie van het ouder worden van personen worden aangeleerd. Figuur 3.7 toont aan dat men op verschillende stadia van het ouderworden, features extraheert en deze bijhoudt in een
12
3 Literatuurstudie
vector. Deze vector noemt men een subspace. Er zullen verschillende subspaces ontstaan, elk met hun eigen patroon. Subspaces met gelijkaardige patronen zullen worden samengevoegd tot ´ subspace om de hoeveelheid subspaces te limiteren. e´ en
Figuur 3.7: Evolutie van het ouder worden
Indien men nu de leeftijd wilt bepalen van een nieuw gezicht, biedt men dit gezicht aan aan eenzelfde feature extractor als in de opstelling van de vector gebruikt is. Om de exacte leeftijd te kunnen bepalen, zullen twee stappen nodig zijn:
1. Bepaling van het meest bruikbare patroon (subspace) 2. Bepalen van de juiste positie in dit patroon
Het bepalen van het juiste patroon gebeurt via de minimum-reconstructie-fout. Dit is de afwijking aanwezig bij de reconstructie van het gezicht door middel van waarden van de positie in het patroon. Alleen is deze positie niet gekend en kan deze afwijking dus niet berekend worden. De enige mogelijkheid om dit probleem op te lossen is om de nieuwe afbeelding op alle mogelijke posities te plaatsen en hieruit de corresponderende afwijking te berekenen. Vervolgens wordt het minimum van al deze berekeningen bepaald en dit minimum bepaalt ook onmiddellijk het patroon en de positie in dit patroon. Uiteindelijk wordt de geassocieerde leeftijd teruggegeven. De performantie van dit algoritme indien men de Hit Rate bekijkt, ligt veel hoger dan andere technieken. De conclusie van Geng et al. (2006) vertelt ons dan ook dat het een enorm performant algoritme is ten opzichte van anderen en dat het succes te danken is aan de nieuwe technieken en ¨ ideeen.
3 Literatuurstudie
3.3.2
13
Skin Wrinkle Analysis
Een andere methodiek maakt gebruik van de rimpels op de gezichten van mensen. Kwon and Lobo (1999) bestudeerden hoe effectief zo’n techniek is. Deze techniek maakt het niet mogelijk om de exacte leeftijd te bepalen maar wel om de gezichten te classificeren in een leeftijdscategorie. De techniek heeft twee onderdelen: 1. Zoeken van pimaire features zoals ogen, neus en mond en hiermee ratio’s berekenen voor ¨ het onderscheid tussen de leeftijdscategorieen 2. Zoeken van secundaire features door middel van een geografische map van rimpels en ook hiermee ratio’s berekenen Beide ratio’s worden dan samengebracht en getest volgens een bepaalde regel. De conclusie geeft ons aan tot welke groep het gezicht behoort.
Figuur 3.8: Rimpelmap. Bevat de regio’s waarin naar rimpels gezocht moet worden
De rimpel analyse wordt uitgevoerd door middel van de rimpelkaart zoals te zien is op figuur 3.8. Op de aangeduide plaatsen zullen er snakelets geplaatst worden en daar gezocht worden naar rimpels. Snakes worden gebruikt als Active Contour Model. Met deze techniek is het de bedoeling de best mogelijke vorm van een rand aan te nemen, wat is dit geval duidt op een rimpel. Soms kunnen gewone randdetectiealgoritmes voldoende zijn maar soms is het resultaat waardeloos. Door gebruik te maken van een minimale energie oplossing, is het mogelijk om deze randen nauwkeuriger te detecteren. Figuur 3.9 toont aan hoe dit precies gebeurt. Dit probleem wordt opgelost door krachten op de omlijning toe te passen. In dit voorbeeld is er een kracht op de omlijning van het vliegtuig. Deze kracht wijst naar het vliegtuig en trekt er dus de lijn naar toe. Zo zal de lijn uiteindelijk mooi het vliegtuig omsluiten en is de rand (overgang van wit naar zwart in dit voorbeeld) vrij nauwkeurig gedetecteerd.
3.4
Geslachtsbepaling
In dit deel van de literatuurstudie worden verschillende methodes toegelicht om het geslacht van een persoon in beeldverwerkende toepassingen te bepalen. In 4.1 zullen we concluderen welke
14
3 Literatuurstudie
Figuur 3.9: Resultaat van edgedetectie door middel van snakes
techniek wij zullen toepassen en waarom.
3.4.1
Local Binary Patterns en Support Vector Machines
Een eerste methode om het geslacht van personen te bepalen is de methode die bestudeerd werd door Lian and Lu (2006). Hierin is de bepaling van het geslacht afhankelijk van zowel de vorm als de textuur dat gevonden kan worden in het gezicht van een persoon. Door het gezicht op te delen ¨ in kleinere delen, waarvan dan LBP histogrammen kunnen geextraheerd worden, is het mogelijk vectoren op te stellen die gebruikt kunnen worden door support vector machines (SVM’s). De twee keypoints in het bepalen van het geslacht van een persoon in een afbeelding zijn de feature extractie en de patroonclassificatie. De feature extractie zal gebeuren op basis van het Local Binary Patterns algoritme, uitgelegd in 3.2. De resulterende histogrammen bevatten informatie over de verdeling van lokale patronen zoals randen of egale oppervlakken. De techniek van Lian and Lu (2006) zorgt eerst voor de bepaling van de positie van de ogen en normaliseert. Hierop het LBPalgoritme uitgevoerd, resulteert in een zogenaamd LBP gezicht zoals te zien in figuur 3.10. Dit gezicht wordt dan opgedeeld in een rooster en de histogrammen vormen zo een vector dat aan de gender classifier gegeven kan worden.
Figuur 3.10: LBP methode op gezichten. (a) Preprocessed faces, (b) Bijhorende LBP faces, (c) Bijhorende 5x5 rooster LBP faces
Deze vector wordt vervolgens door de SVM geanalyseerd en hieruit wordt beslist tot welk geslacht deze vector, of dus het gezicht in beeld, behoort. Deze methode bevat zeer performante technieken
3 Literatuurstudie
15
(LBP en SVM) en tegelijk een hoge detectiegraad van 96.75% op de CASPEAL dataset.
3.4.2
Gender Recognition from Body
Een andere methodiek is het bepalen van het geslacht op het volledige lichaam van de persoon in beeld. Cao et al. (2008) heeft hiernaar een studie gedaan. Dit was op dat moment de eerste in zijn soort omdat er een grote natuurlijke variatie is van het menselijk lichaam. Door eerst de afbeelding op te splitsen in kleinere modellen, kunnen ze kenmerken detecteren die het geslacht van de persoon kunnen bepalen. Al deze kenmerken worden dan aan een algoritme aangeboden die van die lichaamsdelen weet bij welk geslacht bepaalde kenmerken horen. Voor zo’n aanpak is het belangrijk te weten welke karakteristieken belangrijk zijn voor de geslachtsbepaling. Indien deze bekend zijn, moet er bepaald worden hoe een beslissing genomen wordt op basis van deze karakteristieken. De specifieke eigenschappen worden gedetecteerd door twee verschillende technieken te combineren: een edgedetectie voor de ruwe vorm en een HOG voorstelling. Deze verschillende technieken op een afbeelding toegepast zijn te zien op figuur 3.11
Figuur 3.11: Voorstelling van de verschillende technieken. (a) originele afbeelding, (b) edge map, (c) Histogram of Oriented Gradients (HOG)
In de conclusie van deze studie is het duidelijk dat deze aanpak een heel hoge nauwkeurigheid biedt. Toch is er een groot nadeel aan: de pose van de persoon in beeld blijft belangrijk. Een afwijkende pose kan ervoor zorgen dat de persoon niet gedetecteerd wordt of dat het geslacht foutief bepaald wordt.
3.5
Platformen en omgevingen
Om ons gehele algoritme uit te kunnen voeren, zullen we beroep moeten doen op software en een besturingssysteem. In deze paragraaf onderzoeken we welke verschillende softwaremogelijkheden we hebben en op welk besturingssysteem deze beschikbaar zijn. Deze studie is afhankelijk van de bestudeerde technieken in 3.2. Omdat het besturingssysteem voor ons niet de beslissende factor is, beginnen we met het zoeken naar de verschillende softwaremogelijkheden. Enkele bekende programma’s om beeldverwerkende toepassingen te schrijven zijn:
• OpenCV • Libccv
16
3.5.1
3 Literatuurstudie
OpenCV
´ van de meest gebruikte bibliotheken in de wereld van de computervisie. De reden OpenCV is e´ en is heel simpel: vele technieken zijn volledig uitgewerkt in deze bibliotheek en deze is open-source. Het is dan ook niet bijzonder moeilijk om aan de slag te gaan met dit pakket. Ook dankzij de vele online documentatie en fora, is het mogelijk om als nieuweling in de computervisie een simpele detector aan de praat te krijgen. OpenCV gebruikt als programmeertaal C++, een taal die zeker niet onbekend is bij ons. OpenCV is een bibliotheek die makkelijk aanspreekbaar is en waarover veel informatie te vinden is, wat zeker een pluspunt is als er problemen optreden. Wanneer we spreken over vele technieken, zijn dit uiteraard niet alle technieken. Technieken zoals ´ zijn wel te vinden voor OpenCV, maar zitten er niet standaard bij. Technieken zoals die van Dollar Viola en Jones (haar-cascade), LBP en HOG zitten dan wel standaard in deze bibliotheek met zelfs voorgetrainde persoons- en gezichtsdetectoren. OpenCV is beschikbaar voor zowel Windows, Linux als Mac.
3.5.2
Libccv
Libccv is ook een open-source bibliotheek. Het is een Modern Computer Vision Library dat ons in staat stelt moderne visie-algoritmes te gebruiken in eigen geschreven software. Deze bibliotheek bevat minder implementaties dan OpenCV, maar de ge¨ıntegreerde implementaties zijn enorm geoptimaliseerd. Hoewel deze bibliotheek afhankelijk is van andere bibliotheken voor de beste performantie en features, werkt het ook wanneer de algoritmes gewoon in een reeds bestaand project gebruikt worden. De schrijvers van de libccv bibliotheek zijn er aich bewust van dat er geen tekort is aan performante en goede algoritmes, maar eerder aan goede implementaties. Dit is waarvoor libccv echt staat: extra snelle en goede implementaties in C++ van de nieuwe algoritmes. Omdat libccv een kleiner project is, is er jammer genoeg ook minder informatie over te vinden. Dit kan leiden tot het vastlopen van het onderzoek of het aanpassen van onze aanpak. Libccv is enkel beschikbaar voor Linux.
3.6
Evaluatie
De bedoeling van dit hoofdstuk was onderzoek doen naar reeds bestaande technieken om objecten te detecteren in beelden, technieken om deze detecties te classifceren, welke denkwijzes reeds uitgeprobeerd zijn om het geslacht en de leeftijd van personen in beelden te bepalen en wat de performantie en nauwkeurigheid van deze methodes is. Ook is bestudeerd welke softwarepakketten voor handen zijn om beeldverwerkende toepassingen te maken. We zullen nu al deze kennis bundelen en een vergelijking maken tussen de verschillende bestudeerde technieken en methodes. Hiermee kunnen we in 4 een concreet besluit vormen. ´ Indien we de verschillende technieken uit 3.2 met elkaar vergelijken, steekt de techniek van Dollar er met kop en schouders bovenuit. Op figuur 3.12 is er een vergelijkende studie getoond tussen de verschillende besproken technieken. Deze figuur zet de miss-rate uit tegenover de false positives in een afbeelding. Elke techniek tracht zo weinig mogelijk false positives te behalen, dit zijn namelijk foutive detecties. Men tracht ook de miss-rate zo laag mogelijk te houden aangezien deze duidt op het aantal ontbrekende detecties ten opzichte van het totale aantal detecties. Hiermee ligt het
3 Literatuurstudie
17
optimale punt op deze grafieken in 0,0 (linksonder). Op dit punt worden er namelijk geen foutive detecties uitgevoerd en worden er ook geen te detecteren objecten gemist.
Figuur 3.12: Resultaten van de verschillende technieken op verschillende datasets bij het detecteren van personen
´ et al. (2009), tonen de resultaten van het detecteren van persoDeze grafieken, gehaald uit Dollar ´ (ChnFltrs) nen op verschillende datasets. Hieruit is duidelijk te besluiten dat de techniek van Dollar de beste resultaten boekt. ´ Libccv is de bibliotheek met de meest geoptimaliseerde technieken en ook de de techniek van Dollar et al. (2009) is hierin ge¨ımplementeerd. Toch zullen we kiezen voor OpenCV omdat dit een bibliotheek is dat reeds verschillende detectoren bevat en waarvan enorm veel documentatie beschik´ et al. (2009) waardoor we zullen baar is. OpenCV bevat standaard geen implementatie van Dollar kiezen voor drie technieken die enorm makkelijk te gebruiken zijn in deze bibliotheek: de Haar-, LBP- en HOG-techniek.
3.7
Conclusie
¨ Om onze conclusie te vormen, keken we naar de mogelijke technieken, hun efficientie en imple´ de techniek is met de beste performantie, zullen mentatiemethoden. Hoewel de techniek van Dollar we ervoor kiezen een studie te maken rond drie andere technieken: Haar, LBP en HOG. Aangezien OpenCV een sterke documentatie heeft en reeds verschillende detectoren bevat, kiezen we dit als onze bibliotheek voor het schrijven van ons algoritme. We kunnen nu aan de slag met het opstellen van een algmene werkwijze, het schrijven van het algoritme en het vergaren van resultaten.
Hoofdstuk 4
Uitwerking In dit hoofdstuk beschrijven we de volledige uitwerking van deze thesis. In de literatuurstudie in hoofdstuk 3 hebben we reeds vele technieken en methodieken bestudeerd. We zullen dus eerst starten met het verduidelijken van de grote lijnen van ons algoritme en dit gebeurd in 4.1. Vervolgens zullen we de verschillende onderdelen van ons algoritme in detail bespreken. We starten met het opzetten van onze programmeeromgeving en met het preprocessen van de beelden in 4.3. De beelden zijn dan klaar om aan onze eerste detector gegeven te worden: de persoonsdetector ( 4.4). Indien er personen gedetecteerd worden, zullen deze naar de volgende stap in ons algoritme gebracht worden: de gezichtendetector ( 4.5). Deze zal eventuele gevonden gezichten doorsturen naar de geslachtsclassifier( 4.6). De gedetecteerde personen zullen ook gebruikt worden om in de lengte te bepalen ( 4.7). Al deze informatie wordt dan gebundeld in 4.8: de leeftijdsbepaling.
4.1
Algemene Flow
Vooraleer we kunnen starten met een dieper onderzoek, moeten we vastleggen hoe we ons probleem zullen aanpakken. Er staan namelijk enkele vragen op een antwoord te wachten:
• Hoe verloopt ons algoritme in het algemeen? • Op welke basis voeren we de leeftijdsbepaling uit? • Welke techniek willen we gebruiken om het geslacht te bepalen? 4.1.1
Geslachtsbepaling
In de literatuurstudie hebben we gezien dat er verschillende methodes bestaan om het geslacht ´ en ´ van de bestudeerde methodes classificeert op basis van de van een persoon te bepalen. E gehele persoon, dus het gehele lichaam. Een nadeel van deze techniek is om zo een detector te trainen voor onze opstelling, een enorme hoeveelheid aan trainingsvoorbeelden nodig zullen zijn om de personen te kunnen classificeren in de verschillende posities. Een ander nadeel is dat er ´ keer. nadien weinig mogelijkheid tot aanpassing is want de detectie en classificatie gebeuren in e´ en Toevoeging of lichte aanpassing van de features van het programma is dus niet mogelijk. Wanneer we de andere methode gebruiken, diegene die zijn geslachtsbepaling baseert op het gezicht, is het mogelijk de verschillende detecties uit elkaar te halen, wat meer ruimte geeft om 19
20
4 Uitwerking
nadien stappen toe te voegen of andere technieken te gebruiken. We kunnen eerst de personen detecteren in ons beeld en in deze gedetecteerde regio’s zoeken naar gezichten van een bepaald geslacht. Ook hierin maken we een opsplitsing om te onderzoeken of onze gebruikte techniek betere prestaties oplevert dan de prestaties van Lian and Lu (2006). Wij zullen in plaats van het zoeken naar een mannelijk gezicht en een vrouwelijk gezicht, eerst een detectie doen op algemene gezichten. Wanneer er geen gezicht gevonden is, weten we dat we ook geen geslachtsbepaling ´ zullen kunnen uitvoeren. Wanneer er wel een gezicht gevonden wordt, hoeven we slechts e´ en detectie uit te voeren, namelijk een mannelijke. Indien deze detector een mannelijk gezicht detecteert, is dit ons resultaat. Indien er geen mannelijk gezicht wordt gedetecteerd, is het resultaat een vrouw. Door eerst een detectie te doen naar het gezicht, kunnen we dit resultaat nadien nog gebruiken om andere detecties of classificaties uit te voeren. De techniek van het achter elkaar plaatsen van detectoren en classifier, heet een cascade. Het zal ons later de mogelijkheid geven om additionele features aan het algoritme toe te voegen zoals bijvoorbeeld delen van een persoon detecteren of andere detecties op het gezicht. Dit zorgt voor een enorm flexibel algoritme en is voor gebruik in de reclame-industrie een belangrijke troef.
4.1.2
Leeftijdsbepaling
Wanneer het gaat over het bepalen van de leeftijd van een persoon, is het zelfs voor ons moeilijk om dit te doen. Er zijn enkele factoren waarop we ons kunnen baseren, maar de verscheidenheid aan mensen is enorm. Ook hier hebben we een studie naar gedaan en zijn er ook reeds verschillende technieken bestudeerd. De techniek die gebruik maakt van de rimpels, lijkt ons te moeilijk. We zullen namelijk geen gebruik maken van High Definition camera’s wat het dan zeer moeilijk maakt om een nauwkeurige randdetectie uit te voeren. Een te kort aan details kan ervoor zorgen dat de leeftijdsbepaling volledig mislukt. Indien we gebruik willen maken van de evolutie van het ouderworden, vrezen we voor de perfor´ van onze vereisten is een real-time systeem en wanneer we moeten zoeken in tal van mantie. E´ en subspaces en leeftijden, zal het onmogelijk zijn om dit nog real-time uit te voeren. Ten tweede heeft de reclame¨ındustrie geen nood aan een exacte leeftijd. Reclame wordt gemaakt voor leeftijdsgroepen, niet voor specifieke leeftijden. Daarom zullen wij een nog andere methode toepassen. Onze methode categoriseert de personen in beeld in leeftijdsgroepen afhankelijk van hun lengte. Door een statistiek te implementeren die de gemiddelde lengte van mannen en vrouwen op bepaalde leeftijden weergeeft, kunnen we afhankelijk van de lengte van de persoon en het geslacht de persoon indelen in een groep. Het is dus wel nodig om eerst het geslacht en de lengte te bepalen alvorens we de persoon kunnen classificeren in een leeftijdsgroep.
4.1.3
Conclusie
Onze drie vragen kunnen we nu beantwoorden. Onze eerste vraag over hoe het algoritme in het algemeen verloopt, kunnen we beantwoorden met de cascademethodiek en dit wegens de flexibiliteit. Onze tweede vraag ging over de leeftijdsbepaling. Daar we er niet vanuit gaan dat onze camera hogekwaliteitsbeelden levert, lijkt het ons veiliger om te werken met de lengte van de persoon. We zullen hier dieper op ingaan in 4.7. De derde vraag betreft het bepalen van het geslacht van een persoon. Volgens onze studie is het
4 Uitwerking
21
aangewezen om in plaats van de gehele persoon te gebruiken als basis voor het geslacht, enkel het gezicht te benutten. Indien dit niet voldoende is, kunnen we nog extra detecties of classificaties uitvoeren aangezien dit mogelijk is met de cascade van detectoren. Onze algemene flow is nu opgesteld zoals we op figuur 4.1 kunnen zien. Figuur 4.2 geeft een grafische voorstelling weer van hoe de drie detectoren de informatie aan elkaar zullen doorgeven. We kunnen nu aan de slag gaan met het programmeren van het algoritme.
Figuur 4.1: Flow van het algoritme
Figuur 4.2: Grafische voorstelling van de detectoren in het algoritme met a) persoonsdetectie, b) gezichtsdetectie en c) geslachtsbepaling
4.2
Programmeeromgeving
Uit onze literatuurstudie kunnen we concluderen dat we het best OpenCV kunnen gebruiken ten opzichte van libccv. Aangezien het besturingssysteem voor ons niet belangrijk is, hebben we besloten Linux te gebruiken. Deze linuxomgeving is Ubuntu 12.04 LTS(Long Term Support).
22
4.3
4 Uitwerking
Voorbereiding van de beelden
Om onze classificatie doeltreffend te maken, is het noodzakelijk ervoor te zorgen dat de beelden die we gebruiken zich in een zo goed mogelijke staat bevinden. Daarom zullen we eerst enkele stappen doorlopen om de beelden klaar te maken voor onze eerste detector. De meeste cascadedetectoren houden geen rekening met de kleur van de beelden. Daarom is het dus ook niet nodig deze informatie bij te houden. De eerste stap is dus de kleurenafbeelding om te vormen naar een afbeelding met grijswaarden. De informatie die we verliezen betekent hier niet dat we een slechtere detectie zullen maken. Het heeft zelfs het voordeel dat we geen tijd verliezen met het bijhouden van deze informatie. De tweede voorbereidende stap in ons algoritme is de histogram-equalisation. Het histogram van een afbeelding geeft de verdeling van de intensiteit weer. Het telt het aantal pixels die een bepaalde intensiteit hebben en zet deze uit in een histogram zoals in figuur 4.3. Om het contrast van een een afbeelding te verbeteren, kan men de waarden van dit histogram proberen gelijk te trekken door bepaalde pixelintensiteiten te verschuiven naar plaatsen van minder gebruikte intensiteiten zoals aangeduid met de groene cirkels op 4.4. Deze figuur geeft ook het resultaat van deze bewerking: een afbeelding met een hoger contrast.
Figuur 4.3: Histogram van een afbeelding
Figuur 4.4: Histogram equalization
Nu onze beelden klaar zijn voor verdere verwerking, kunnen we overgaan naar de detectie van de personen.
4 Uitwerking
4.4
23
Persoonsdetectie
Om de geslachts- en leeftijdsbepaling te kunnen uitvoeren van voorbijgangers, is het noodzakelijk eerst de voorbijgangers zelf te detecteren. De reden dat we de volledige persoon wensen te detecteren, komt van het feit dat we de leeftijdsbepaling willen uitvoeren op basis van de lengte van de persoon en omdat we een enorm flexibel programma willen bouwen. Gelukkig bestaan er reeds tal van persoonsdetectoren, ofwel pedestrian detectors, waarvan we enkele met elkaar zullen vergelijken. Een van de meest voorkomende soorten is diegene gebaseerd op de haar-wavelets. Een andere techniek is HOG. In OpenCV zit reeds een persoonsdetector gebaseerd op een cascade techniek. ¨ In OpenCV kunnen we aan de cascade detectoren vier parameters meegeven om hun efficientie te verbeteren: 1. Vergrotingsfactor 2. Aantal overlappingen 3. Minimum grootte 4. Maximum grootte De vergrotingsfactor bepaalt de verschillende schalen waarop gezocht wordt naar het object (in ons geval een persoon). Een vergrotingsfactor van 1,1 zal elke keer als de volledige foto overlopen is, de schaal vergroten met 10% en terug zoeken naar het object. Hoe kleiner de vergroting, op hoe meer schalen er gezocht zal worden naar personen en dus hoe nauwkeuriger het resultaat zal zijn maar ook hoe langer het proces zal duren. Het aantal overlappingen bepaalt hoeveel er nodig zijn vooraleer de detectie een effectief resultaat oplevert. Wanneer de detector ingesteld is op 8 overlappingen, zal op 8 verschillende schalen op dezelfde plaats een detectie moeten gedaan worden vooraleer deze regio als een effectieve detectie wordt aanschouwd. De minimum en maximum grootte bepalen de extreemste waarden van de schaal waarop detecties zullen uitgevoerd worden. Deze parameters kunnen enorme snelheidsoptimalisaties voortbrengen wanneer deze ingevuld worden. Uiteraard is dit alleen mogelijk wanneer de toepassing dit toelaat. In ons geval kunnen we van deze parameters gebruik maken.
4.4.1
Haar
De Haar-detector is een detector die standaard bij OpenCV zit. Het is een veelgebruikte persoonsdetector die, indien de parameters correct zijn ingesteld, goede resultaten oplevert. Het grote nadeel aan de haar-detectoren is hun snelheid en dit is ook te merken wanneer we proberen realtime personen te detecteren. Wanneer we een schalingsfactor van 1,1 en een overlap van 10 toepassen, loopt het hele systeem traag. Enkel wanneer we de schalingsfactor genoeg vergroten (1,2 tot 1,3), is het mogelijk detecties real-time uit te voeren.
4.4.2
HOG
Ook de HOG-detector zit bij OpenCV. Hierbij geldt dezelfde regel: bij een goede parameterinstelling zal deze detector goed presteren. Deze detector maakt het mogelijk om de personen real-time te
24
4 Uitwerking
detecteren vanwege zijn goede verwerkingssnelheid. De meest optimale parameters zijn uiteraard afhankelijk van de situatie maar in onze opstelling voor de HOG-detector zijn deze de volgende: Schalingsfactor: 1.1 Overlap: 20 Minimum grootte: 100 x 100 Maximum grootte: 30 pixels minder dan de gebruikte afbeelding
4.4.3
Evaluatie
Beide technieken leveren resultaten op die te gebruiken zijn hoewel de Haar-detector de real-time vereiste in gevaar kan brengen. De nauwkeurigheid van de detecties is enorm afhankelijk van de schalingsfactor en aangezien de Haar-detector het systeem vertraagt bij nauwkeurige detecties, zullen we deze niet gebruiken om personen te detecteren in onze afbeeldingen. Zoals in figuur 4.5 te zien is, hebben we een rode kader rond de detecties getekend voor een goede visualisatie en wordt er ook aangetoont dat er regio’s foutief gedetecteerd worden. Dit kunnen we wegwerken door de parameters aan te passen, of pas in een latere stap de visualisatie te maken wanneer we zeker zijn dat dit een persoon is die we kunnen classificeren. Om in de volgende stappen van ons algoritme een snelheidswinst te bekomen, zullen we de gedetecteerde personen uit de afbeelding halen en zullen we enkel de persoon doorgeven aan de gezichtsdetector. Hiermee hoeft de gezichtsdetector niet over de gehele afbeelding te zoeken, maar enkel over de persoon. Een nog eventuele aanpassing is slechts het bovenste deel van de persoon door te geven, aangezien zich in het onderste deel geen gezichten bevinden. We hebben ook voor een extra marge rondom de detectie gezorgd. Hiermee bedoelen we dat we de eigenlijke detectie vergroot hebben met 60 pixels in hoogte (30 pixels onderaan en 30 pixels bovenaan). Dit omdat de persoonsdetectie niet altijd even nauwkeurig is en niet steeds de volledige persoon detecteert. Bij de lengtebepaling moeten we er zeker van zijn dat we de volledige persoon doorsturen en dankzij deze marge is dit het geval.
4.4.4
Besluit
Beide technieken leveren goede resultaten op indien de parameters correct worden ingesteld maar wij zullen de HOG-detector gebruiken omdat we de toepassing real-time willen uitvoeren. Ter visualisatie van deze detectie wordt er een rode kader rond het gedetecteerde gebied getekend. ¨ Dit gebied wordt vervolgens gekopieerd naar een nieuwe afbeelding die gebruikt zal worden door de volgende detector. Nu we onze persoon hebben gedetecteerd, kunnen we doorgaan naar de volgende stap in het algoritme: de gezichtsdetectie.
4.5
Gezichtsdetectie
Dankzij de pedestrian-detector van OpenCV hebben we nu onze persoon uit het beeld kunnen halen. Uit onze studie hebben we besloten dat we eerst het gezicht van deze persoon willen lokaliseren vooraleer we het geslacht bepalen van de persoon in kwestie. Uiteraard moet het gezicht van de persoon in de richting van de camera kijken. In OpenCV zit reeds een gezichtsdetector en in dit onderdeel zullen we enkele testen uitvoeren.
4 Uitwerking
25
Figuur 4.5: Visualisatie van de persoonsdetectie met rechts de uitgeknipte persoon
4.5.1
Haar
Een beschrijving van de op de Haar gebaseerde techniek is ook terug te vinden in de bibliotheek van OpenCV. We gebruiken deze detector voor het detecteren van de gezichten. Ook hier zijn dezelfde parameters beschikbaar als bij 4.4. Omdat de dimensies van de doorgestuurde persoon meestal veel kleiner zijn dan de volledige afbeelding, kunnen we hier enorm nauwkeurig werken. Er zijn namelijk veel minder schalen mogelijk waarop een gezicht te detecteren valt. Daarom hebben we dan ook de schalingsfactor 1,05 gemaakt omdat dit ons de beste resultaten opleverde. Het aantal overlappingen hebben we gehouden op 5 en dit om ervoor te zorgen dat we het gezicht, indien het minder duidelijk is, toch kunnen detecteren. De maximale grootte is vastgelegd omdat we trachtten een snelheidsverbetering te bereiken. Aangezien het gezicht slechts een klein deel van de persoon is, kunnen we de maximale grootte op 30% van de uitgeknipte persoon houden. Schalingsfactor: 1.05 Overlap: 5 Minimum grootte: kleinst mogelijke Maximum grootte: 30 pixels kleiner dan de uitgeknipte persoon
4.5.2
LBP
Ook een LBP-gezichtsdetector is aanwezig in OpenCV. Hierbij hebben we dezelfde parameterinstellingen gebruikt als bij de Haar-detector.
26
4.5.3
4 Uitwerking
Evaluatie
De gezichtsdetector is een vrij stabiele en nauwkeurige detector. Ook hier is er een groot verschil in snelheid tussen Haar en LBP. De Haar-detector doet het met deze parameters bijzonder slecht in snelheid, maar detecteert bijna alle gezichten. De LBP-detector presteert met dezelfde parameters veel beter in snelheid, maar detecteert niet alle gezichten. We maken natuurlijk gebruik van zeer nauwkeurige detecties (vele schalingen) omdat het gezicht ook in vele maten kan voorkomen. We kunnen wel een optimalisatie toepassen door in plaats van de gehele persoon, enkel het bovenste deel van het lichaam door te sturen naar de gezichtsdetector. Hiermee verkleinen we nogmaals de oppervlakte wat vooral voor de Haar-detector een verbetering is. De afbeelding van de gehele persoon hebben we nog steeds nodig bij het bepalen van de lengte. Zoals bij de persoonsdetectie hebben we hier ook gezorgd voor een extra marge rondom het gedetecteerd gezicht. We doen dit om een betere detectiegraad te bereiken met de geslachtsdetector. We nemen hier een extra marge ter grootte van 30 pixels in hoogte en breedte.
Figuur 4.6: Visualisatie van de gezichtsdetectie met rechts het uitgeknipte gezicht
4.5.4
Besluit
We kunnen besluiten dat indien we onze vereisten willen halen, we beroep kunnen doen op de zowel de Haar- als de LBP-gezichtsdetector aangezien deze met zeer nauwkeurige parameters, snel resultaat opleveren. In het geval van de Haar-detector is het wel noodzakelijk enkel het bovenste deel van het lichaam te gebruiken omdat anders de verwerking niet real-time gebeurt. Wanneer de gezichtsdetector een detectie maakt, weten we dat we verder kunnen gaan met het algoritme. Wanneer dit niet het geval is, kunnen we dan ook de rest van ons algoritme overslaan aangezien we dan niet voldoende informatie verzameld hebben om zowel het geslacht als de leeftijd te bepalen. We zouden wel de lengte van de persoon kunnen bepalen maar dit heeft geen nut. We kunnen nu doorgaan naar de volgende stap in ons algoritme: de geslachtsdetectie.
4 Uitwerking
4.6
27
Geslachtsclassificatie
In dit onderdeel van de uitwerking zullen we een aantal testen uitvoeren en werkwijzen uitproberen om het geslacht van een persoon op basis van zijn gezicht te bepalen.
4.6.1
Datasets
Wanneer we een detector of een classifier willen trainen, is het noodzakelijk een verzameling te hebben van de objecten die we willen detecteren of classificeren. We noemen dit een dataset. We zouden zelf een dataset kunnen samenstellen maar hiervoor hebben we enkele honderden proefpersonen nodig wat we niet ter beschikking hebben. Daarom zullen we beroep doen op verschillende instanties die dergelijke datasets aanbieden. In onze training zullen we gebruik maken van volgende datasets:
• Labeled Faces in the Wild • De BioID Face Database V1.2 (1507 frontale foto’s, 963 mannelijk) • De Colorferet dataset (2722 frontale foto’s, 1715 mannelijk) Dit wil zeggen dat delen van het onderzoek in deze thesis gebruik maken van de FERET database van afbeeldingen van gezichten verzameld onder het FERET programma, gesponsord door de DOD Counterdrug Technology Development Program Office.
4.6.2
Cascade training
Met deze datasets kunnen we nu onze algoritme trainen. We voeren de training in OpenCV uit via de cascade methode die OpenCV ons biedt. Om de training te starten, moeten we OpenCV laten weten wat de positieve en wat de negatieve afbeeldingen zijn. De positieve afbeeldingen zijn in deze studie de mannengezichten en dit zijn de gezichten die we wensen te detecteren. De negatieve zijn gezichten van vrouwen aangezien deze niet gedetecteerd moeten worden. Deze aanpak is mogelijk omdat we reeds weten of er een gezicht aanwezig is of niet. Wanneer dit gezicht geen mannengezicht is, moet het wel een vrouwengezicht zijn. We hoeven ook geen andere objecten toe te voegen bij de negatieve afbeeldigen omdat we geen ander object zullen doorgeven aan de geslachtsdetector. De verschillende datasets hebben we zelf gelabeld in mannen- en vrouwengezichten. De verschillende detectoren zijn getraind met:
• Posturen van mannen (hoofd tot schouders) vanuit de labeled faces in the wild dataset • Zelf geannoteerde hoofden van mannen vanuit de labeled faces in the wild dataset • Zelf geannoteerde hoofden van mannen uit de BioID Face dataset • Gezichten van mannen door de facedetector geannoteerd vanuit de Color FERET dataset • Gezichten van mannen door de facedetector geannoteerd vanuit de FERET en de BioID datasets
28
4 Uitwerking
• Gezichten van mannen door de facedetector geannoteerd vanuit de FERET, BioID en LFW datasets Deze trainingen zullen gebeuren op basis van drie verschillende methodes:
• Haar • LBP • HOG Al deze trainingen werden uitgevoerd met dezelfde parameters. Hierbij werd het aantal stages op de standaard (20) gehouden en de grootte van de positieve afbeeldingen was steeds 24 op 24 pixels (dit was niet het geval voor de zelf geannoteerde trainingen aangezien de verhoudingen van de hoogte en de breedte anders lagen). Het aantal positieve afbeeldingen hebben we gelijkgesteld aan 85% van ons totaal aantal positieve afbeeldingen en dit om een aantal reserve afbeeldingen over te houden voor het trainingsalgoritme. Alle andere parameters hebben hun standaardwaarde behouden.
4.6.3
Evaluatie
De training is pas effectief wanneer we enkel de gezichten van de mannen gebruiken die door de facedetector gedetecteerd zijn. De posturen geven alles behalve succesvolle detecties, alsook de zelfgeannoteerde. De oorzaak van dit resultaat is te wijten aan het aantal positieve afbeeldingen die aangeboden zijn aan de training. Er is weinig verschil in detectiegraad tussen de Haar en de LBP technieken maar de tijd nodig om een detector te trainen via de Haar-techniek is enkele malen groter dan op basis van de LBPtechniek. Zo duurde het voor de haar-techniek bij de voorlaatste training maar liefst 4 uur en 32 minuten terwijl de LBP-techniek de training afrondde in een 4-tal minuten. Ook de HOG-training verliep bijzonder traag (5 uur en 29 minuten).
4.6.4
Besluit
Het is mogelijk om met OpenCV verschillende detectoren te trainen die steunen op verschillende technieken. Het resultaat van deze trainingen is afhankelijk van de aangeboden afbeeldingen. De trainingsduur is afhankelijk van de gebruikte techniek.
4.7
Lengtebepaling
We hebben een persoon en een gezicht in de afbeelding gevonden en we hebben ook het geslacht van deze persoon kunnen bepalen. Nu is het de beurt aan de lengtebepaling.
4.7.1
´ en ´ camera E
´ camera mogen gebruiken. Dit zorgt voor een moeiIn onze vereisten staat er dat we slechts e´ en lijkheid want de wereld waarin wij leven is drie-dimensionaal en een camera kan slechts twee van deze dimensies vastleggen. Wanneer de camera zich dus aan het bord bevindt, is de afstand tot
4 Uitwerking
29
de persoon (de diepte) onbekend. We zullen nu een methode verduidelijken waarmee we toch in staat zijn deze afstand te berekenen om hiermee de werkelijke lengte van een persoon te bepalen.
Figuur 4.7: Parameters nodig voor de lengtebepaling
Figuur 4.8: Camerastandpunt bij lengtebepaling
Wanneer een object zich verder van de camera bevindt, zal het object kleiner voorgesteld worden op het beeld. De diepte is dus een belangrijke factor. De afstand van de camera tot het punt waar het beeld begint, noemen we de beginafstand. In deze studie nemen we dan wel aan dat dit punt dan ook direct de ondergrond is. Als we ook weten wat de afstand tot de camera is op het verste punt van de ondergrond, en we weten wat de pixelhoogte op het beeld hiervan is, kunnen we ´ pixel in het beeld voorstelt. Deze berekening gaat als volgt: berekenen hoeveel cm in diepte e´ en
fdiepte =
deind − dbegin yeind
(4.1)
Hierin is deind de afstand van de camera tot het einde van de ondergrond, dbegin de afstand van ¨ de camera tot de onderkant van het beeld en yeind de y-coordinaat van pixel waar de ondergrond op het beeld stopt. Dit kan bijvoorbeeld de horizon zijn. Wanneer de onderkant van het beeld ¨ van de camera nog niet de ondergrond voorstelt, zal ook de y-coordinaat van het begin van de
30
4 Uitwerking
ondergrond in rekening gebracht moeten worden. Hieruit volgt dat deze beide pixelhoogtes van elkaar afgetrokken zullen worden.
fdiepte =
deind − dbegin yeind − ybegin
(4.2)
Het resultaat van deze bewerking zullen we de dieptefactor noemen. We kunnen nu de afstand bepalen van de persoon tot aan de camera door de pixelhoogte van het onderste punt van de persoon in beeld te vermenigvuldigen met deze dieptefactor en hier de beginafstand bij te tellen. Het resultaat geeft ons de diepte in cm.
d pers = dbegin + ( fdiepte · yvoet )
(4.3)
¨ yvoet is de y-coordinaat van de pixelpositie van de voet van de persoon. Een specifiek kenmerk aan een normale camera is het feit dat wanneer een persoon op een bepaalde afstand een zekere grootte heeft, dan zal deze grootte op het beeld twee keer verkleinen wanneer deze persoon dubbel zo ver gaat staan. Dit moet ook in rekening gebracht worden en we zullen dit de cameraconstante noemen. Deze constante volgt uit volgende vergelijking:
ctecam =
d pers · h pers,pixels h pers,werk
(4.4)
met de d pers de afstand tot het object in werkelijkheid, h pers,pixel de hoogte in pixels van het object op deze afstand en h pers,werk de werkelijke hoogte van het object. Alle factoren van de camera zijn nu gevonden en we zijn nu instaat om de lengte van een persoon te bepalen wanneer de persoon volledig in beeld is en op de grond staat:
l pers =
d pers · h pers,pixels (dbegin + ( fdiepte · yvoet )) · h pers,pixels = ctecam ctecam
(4.5)
Uiteraard is het noodzakelijk dat het algoritme weet wat de afstanden en pixelhoogtes zijn. Deze waardes staan hard gecodeerd maar zoals uitgelegd in het volgende onderdeel, is het mogelijk deze waardes aan te passen. De hard gecodeerde waardes corresponderen met een camerahoogte van 120 cm en een hoek van 20 graden. In ons algoritme bepalen we de hoogte van de persoon in pixels door middel van de hoogte van de persoonsdetectie. Dit is een vrij ruwe schatting omdat de persoonsdetector nogal onstabiel is.
4.7.2
Kalibratie
Toen we startte met het uittesten van dit onderdeel van het algoritme, kwamen we al snel tot het besluit dat de camera wel eens van plaats wisselt. Omdat het nogal eens voorkomt dat de camera op moeilijke posities komt te staan en we dus niet altijd de mogelijkheid hebben om de hoogte en de hoek juist te krijgen, hebben we besloten om een kalibratiefunctie te schrijven. Met de optie ’-calibrate’ kan de camera gekalibreerd worden afhankelijk van de situatie waarin hij staat. Deze functie vraagt de gebruiker om enkele waarden:
• De afstand van het beginpunt van de ondergrond in beeld tot de camera (in cm) • De afstand van het eindpunt van de ondergrond in beeld tot de camera (in cm)
4 Uitwerking
31
• Pixelhoogte van het beginpunt van de ondergrond • Pixelhoogte van het eindpunt van de ondergrond Om deze laatste twee waarden te verkrijgen, wordt er op het scherm het huidige beeld getoond. Er moet vervolgens op het beginpunt en het eindpunt van de ondergrond geklikt worden en de rest wordt verwerkt door de functie zelf. We gaan er wel vanuit dat de verhouding tussen de werkelijke grootte en de afgebeelde grootte in functie van de diepte, constant is.
4.8
Leeftijdsbepaling
We hebben uitgelegd hoe we het geslacht en de lengte van een persoon kunnen bepalen en door middel van deze twee factoren kunnen we een schatting van de leeftijd uitvoeren. We zullen beroep doen op verschillende statistieken (figuur 4.9 en 4.10) omtrent de gemiddelde lengte per geslacht en per leeftijd. We zullen geen exacte waarde berekenen, aangezien deze niet significant zijn, ¨ maar we zullen gebruikmaken van drie leeftijdscategorieen: 1. Personen tot en met een leeftijd van 6 jaar 2. Personen tussen 6 jaar en 12 jaar 3. Personen ouder dan 12 jaar ¨ ligt aan het feit dat de lengte naarmate de De reden dat we kiezen voor deze drie categorieen persoon verouderd, kleiner wordt. Om deze persoon dan in te kunnen delen in een andere categorie, bijvoorbeeld 50+, zullen we beroep moeten doen op nog andere kenmerken dan enkel de lengte. Van Loghum (1998) geeft enkele grafieken (figuren 4.9 en 4.10) weer waarop we kunnen zien wat de gemiddelde lengtes zijn van mannen en vrouwen tot 21 jaar. Hieruit halen we dat de gemiddelde mannelijk persoon van 6 jaar 120,1 cm groot is, een vrouwelijk persoon van dezelfde leeftijd is 118,7 cm groot. Een gemiddelde mannelijke persoon van 12 jaar is 154 cm groot en een vrouwelijk persoon van deze leeftijd is 155,3 cm groot. Op basis van deze waarden zullen we een indeling maken en hieruit blijkt ook dat we dus eerst het geslacht en de lengte zullen moeten bepalen vooraleer we een leeftijd kunnen toekennen. De toekenning van de leeftijdscategorie is eenvoudig. Als we het geslacht en de lengte hebben bepaald, kunnen we de lengte vergelijken met de gemiddelde lengtes per geslacht. Wanneer deze lengte 10% groter is dan die van een 6 jarige, behoort deze tot de eerste categorie (0 tot 6 jaar). Wanneer de lengte groter is dan 10% van de lengte van een 12 jarige, dan behoort de persoon tot de derde categorie. In het andere geval behoort deze persoon tot de tweede categorie.
32
4 Uitwerking
Figuur 4.9: Groeicurve van jongens
Figuur 4.10: Groeicurve van meisjes
Hoofdstuk 5
Resultaten 5.1
Algemene performantie
´ en ´ van de belangrijkste vereisten van ons programma is het real-time kunnen classificeren. WanE neer we het volledige programma zijn werk laten doen, is dit systeem volledig real-time gebruik makend van een webcam en een computer. Het systeem heeft geen moeilijkheden met het classificeren van meerdere personen in beeld, althans wanneer de parameters correct worden ingevuld. Wanneer de schalingsfactor van de personendetector enorm laag ingesteld wordt, zal het voor het systeem niet mogelijk zijn de verwerking real-time uit te voeren.
5.2
Nauwkeurigheid
De nauwkeurigheid van een detectiesysteem kunnen we bepalen door de detecties onder te verdelen. We kunnen deze opdelen in: True positives (TP): is het aantal correct gedetecteerde objecten False positives (FP): is het aantal incorrect gedetecteerde objecten False negatives (FN): is het aantal niet gedetecteerde objecten Met deze waarden kunnen we de precision en de recall van een detectiesysteem als volgt berekenen:
TP T P + FP TP Recall = T P + FN
Precision =
(5.1) (5.2)
Precision staat voor het aantal correcte detecties ten opzichte van het totale aantal detecties. De recall staat voor het aantal correcte detecties ten opzichte van het aantal relevante detecties waarbij de relevante detecties ook de niet gedetecteerde objecten bevatten. Omdat we zelf een geslachtsdetector getraind hebben, zullen we ook enkel hiervan de nauwkeurigheid bepalen. We hebben drie detectoren, werkende op een andere principe (Haar, LBP en HOG), laten trainen op dezelfde afbeeldingen. Deze afbeeldingen zijn de verzameling van drie 33
34
5 Resultaten
verschillende datasets (Labeled Faces in the Wild, BioID Face Database en Color FERET dataset). In totaal bevat deze verzameling 2642 positieve en 1438 negatieve afbeeldingen. De positieve afbeeldingen zijn bewerkt door middel van een gezichtsdetector zodat enkel het gezicht overblijft. De negatieve afbeeldingen zijn onbewerkt. Om nu de precision en recall waarden te berekenen, maken we gebruik van een vierde dataset: de PICS dataset (Psychological Image Collection at Sterling). Hierop worden de drie detectoren getest en hieronder vindt u de resultaten: Haar: Precision: 82.7%, recall: 92.2% LBP: Precision: 80.9%, recall: 94.3% HOG: Precision: 93.3%, recall: 46.6% Er is weinig verschil tussen de Haar- en de LBP-techniek wanneer men naar de resultaten kijkt op statische afbeeldingen, maar zoals we reeds ontdekt hebben bij de persoonsdetectie, zal de snelheid van verwerken van real-time afbeeldingen bij de LBP-detector veel hoger liggen. Ook de trainingsduur van de LBP-detector ligt veel lager. Het is duidelijk dat de HOG-techniek geen goede techniek is om geslachtsclassificaties te maken op basis van het gezicht. Hoewel het geslacht van een persoon meestal correct is, is in sommige posities en bij sommige personen de detectie verkeerd. Wanneer de detector nog beter getraind wordt, zal dit zeker de resultaten verbeteren. Het verkeerd detecteren van het geslacht in sommige posities is op figuur 5.1 te zien.
Figuur 5.1: Foutive geslachtsdetectie
De nauwkeurigheid van de lengtebepaling in ons algoritme is enorm afhankelijk van de stabiliteit en nauwkeurigheid van de persoonsdetector. De lengtebepaling gebeurd puur op de verkregen afmetingen van de persoonsdetector. Wanneer deze instabiel is, zal de lengte ook instabiel zijn. Indien we een gemiddelde bepalen, komt de berekende lengte wel overeen met de werkelijke lengte. De
5 Resultaten
35
volledige categorisatie heeft hier niet veel problemen mee, behalve wanneer de schommelingen zich net rond een kantelpunt bevinden. 5.2 en 5.3 zijn voorbeelden van de lengtebepaling in ons algoritme. Hierop is het ook duidelijk dat de lengte schommelt, maar geen extreme waarden kent.
Figuur 5.2: Lengte- en leeftijdsbepaling van een jongen
Figuur 5.3: Lengte- en leeftijdsbepaling van een man
5.3
Totale algoritme
Het totale algoritme kunnen we enkel testen met voldoende beeldmateriaal. De verschillende testen die we uitgevoerd hebben, leverden ons vrij nauwkeurige resultaten op zoals in figuren 5.4 en 5.5 te zien is. Meestal worden de personen goed gedetecteerd, ook de gezichten en het geslacht. De lengte is onstabiel vanwege de onstabiele persoonsdetectie. Toch zijn er enkele verkeerde detecties. Omdat alle gebruikte detectoren foutieve detecties kunnen opleveren, zullen er ook in het eindresultaat fouten zitten. Soms wordt er een gezicht gedetecteerd waar er helemaal geen gezicht aanwezig is. Onze aanpak zorgt ervoor dat dit in de meeste gevallen wordt aanschouwd als een vrouw. Dit kan opgelost worden door naast de mannendetector, ook een ´ van deze detectoren vrouwendetector te trainen. Het gezicht wordt dan eerst aangeboden aan e´ en en indien deze geen detectie oplevert, wordt het gezicht opnieuw aangeboden aan de andere detector. Hierdoor is het mogelijk foutieve gezichtsdetecties uit te sluiten.
36
5 Resultaten
Figuur 5.4: Resultaat van het algoritme op een man
Figuur 5.5: Resultaat van het algoritme op een vrouw
Hoofdstuk 6
Besluit Het doel van deze thesis was het ontwikkelen van een programma voor de reclame-industrie dat hen in staat stelt om personen te categoriseren op basis van hun leeftijd en geslacht. Dit heeft als doel reclame te kunnen weergeven die nuttig is voor de doelgroep die momenteel bij het elektronisch reclamebord aanwezig is. In onze literatuurstudie hebben we verschillende technieken bestudeerd. Hieruit hebben we con´ camera, clusies gemaakt en wel zodanig dat onze vereisten, een real-time systeem met slechts e´ en bereikt kunnen worden. We kwamen tot het besluit een cascade techniek te gebruiken omdat deze enorme flexibiliteit geeft aan het totale pakket. We hebben vervolgens het algoritme in zes delen opgedeeld: preprocessing, persoonsdetectie, gezichtsdetectie, geslachtsdetectie, lengtebepaling en leeftijdsbepaling. Deze zes onderdelen hebben we volledig uitgewerkt in hoofdstuk 4 en hierbij ¨ zijn ook steeds de verschillende onderdelen geevalueerd. De resultaten van het totale programma zijn in hoofdstuk 5 te vinden. Hieruit kunnen we besluiten dat onze vereisten bereikt zijn. We kunnen namelijk personen detecteren in een afbeelding en deze categoriseren op basis van hun leeftijd en geslacht. We doen dit aan de hand van een HOG-persoonsdetector die zijn informatie doorgeeft aan de LBP-gezichtsdetector. Wanneer een gezicht gedetecteerd wordt, zal dit doorgegeven worden aan de Haar- of LBP-geslachtsdetector. De lengte van de persoon wordt na de geslachtsdetector bepaald en dit resultaat samen met het geslacht wordt gekoppeld aan een leeftijd. Dit categoriseren is mogelijk op videomateriaal en dit ´ camera en het programma is zovolledig in real-time. De categorisatie gebeurd slechts via e´ en danig geprogrammeerd dat het mogelijk is voor de gebruiker om, door middel van verschillende parameters, het programma aan te passen naar zijn wensen. Er wordt de mogelijkheid geboden om verschillende trainingsmodellen te gebruiken en parameters voor het gebruik van deze modellen aan te passen. Het is wel noodzakelijk voor het programma dat de personen waarvan leeftijd en geslacht bepaald moet worden, hun gezicht vrijwel frontaal in beeld komt. Ook is het enkel moge¨ te bepalen. Wanneer er onderscheid gemaakt moet worden lijk om specifieke leeftijdscategorieen ¨ zullen extra detectiestappen kunnen toegevoegd worden. Om de tussen meerdere categorieen, nauwkeurigheid van het systeem te verhogen, lijkt het ons verstandig de geslachtsdetector te ver´ daarvan zoekt naar mannelijke gezichten en de andere vangen door twee aparte detectoren. E´ en naar vrouwelijke. Hiermee kunnen we foutieve detecties van de gezichtsdetector wegfilteren. Het resultaat mag er zijn. Personen in beeld worden gedetecteerd en gecategoriseerd op basis van hun geslacht en hun leeftijd en dit in real-time.
37
38
6.1
6 Besluit
Toekomstig werk
Ons programma is uitgewerkt met het gebruik van het gezicht van een persoon om het geslacht te bepalen. Het lijkt ons zeker mogelijk om altijd het geslacht te kunnen bepalen indien er gebruik gemaakt wordt van het volledige lichaam of kenmerken van het lichaam. Deze verschillende detecties zouden dan samengebracht kunnen worden en het resultaat is afhankelijk van de doorslaggevende factor. Als we kijken naar de leeftijdsbepaling, is het ook mogelijk meerdere detecties uit te voeren die een nauwkeuriger resultaat geven en ervoor zorgen dat niet de gehele persoon in beeld moet zijn. Hiermee is het dan wel mogelijk 50-plussers te classificeren en indien gewenst nog meer ¨ categorieen.
Bibliografie Agarwal, S., Awan, A., and Roth, D. (2004). Learning to detect objects in images via a sparse, part-based representation. IEEE Transactions on Pattern Analysis and Machine Intelligence, 26(11):1475–1490. Cao, L., Dikmen, M., Fu, Y., and Huang, T. S. (2008). Gender recognition from body. In In ACM Multimedia, pages 725–728. Dalal, N. and Triggs, B. (2005). Histograms of oriented gradients for human detection. In In CVPR, pages 886–893. ´ P., Tu, Z., Perona, P., and Belongie, S. (2009). Integral channel features. In BMVC. Dollar, Felzenszwalb, P. F. (2010). Object detection with discriminatively trained part based models. Geng, X., Zhou, Z.-H., Zhang, Y., Li, G., and Dai, H. (2006). Learning from facial aging patterns for automatic age estimation. In Nahrstedt, K., Turk, M., Rui, Y., Klas, W., and Mayer-Patel, K., editors, ACM Multimedia, pages 307–316. ACM. Kwon, Y. H. and Lobo, N. D. V. (1999). Age classification from facial images. In In Proc. IEEE Conf. Computer Vision and Pattern Recognition, pages 762–767. Lian, H.-C. and Lu, B.-L. (2006). Multi-view gender classification using local binary patterns and support vector machines. In Wang, J., Yi, Z., Zurada, J. M., Lu, B.-L., and Yin, H., editors, ISNN (2), volume 3972 of Lecture Notes in Computer Science, pages 202–209. Springer. ¨ ¨ ¨ T. (2002). Multiresolution gray-scale and rotation invaOjala, T., Pietikainen, M., and Maenp a¨ a, riant texture classification with local binary patterns. IEEE Trans. Pattern Anal. Mach. Intell., 24(7):971–987. Papageorgiou, C., Oren, M., and Poggio, T. (1998). A general framework for object detection. In ICCV, pages 555–562. Phillips, P. J., Moon, H., Rizvi, S. A., and Rauss, P. J. (2000). The FERET evaluation methodology for face recognition algorithms. IEEE Trans, 22:1090–1104. Phillips, P. J., Wechsler, H., Huang, J., and Rauss, P. (1998). The FERET database and evaluation procedure for face recognition algorithms. Image and Vision Computing J, 16(5):295–306. Van Loghum, B. S. (1998). Url: http://www.gratisbeloningskaart.nl/blog/groeidiagram-voor-delengte-en-gewicht-van-je-kind/. 39
40
BIBLIOGRAFIE
Vapnik, V. N. (1995). The Nature of Statistical Learning Theory. Springer-Verlag New York, Inc., New York, NY, USA. Viola, P. and Jones, M. (2001). Robust real-time object detection. Second International Workshop on Statistical and Computational Theories Of Vision.
Bijlage A
Programma code 1
/ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
2 3 4 5
Software f o r p e r f o r m i n g age and gender d e t e c t i o n based on a t r a i n e d p e d e s t r i a n , f a c e and gender model w i t h t h e a s s i s t a n c e o f an average gender / l e n g t h −> age c h a r a c t e r i s t i c .
6 7
∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗ /
8 9 10 11
/ / i n c l u d e s needed f o r r e a d i n g i n f i l e s c o r r e c t l y and c r e a t i n g o u t p u t # i n c l u d e
# i n c l u d e
12 13 14 15 16 17
/ / OpenCV i n c l u d e s needed f o r c o r r e c t f u n c t i o n a l i t y # i n c l u d e ” opencv2 / o b j d e t e c t / o b j d e t e c t . hpp ” # i n c l u d e ” opencv2 / h i g h g u i / h i g h g u i . hpp ” # i n c l u d e ” opencv2 / imgproc / imgproc . hpp ” # i n c l u d e
18 19 20 21
/ / I n c l u d i n g t h e used namespaces u s i n g namespace s t d ; u s i n g namespace cv ;
22 23 24 25 26 27 28 29 30 31 32 33 34 35
/ / Global v a r i a b l e s C a s c a d e C l a s s i f i e r p e d e s t r i a n , face , gender ; s t r i n g window name = ” Gender and age c l a s s i f i c a t i o n f o r camera i n p u t ” , p e d e s t r i a n w i n d o w = ” P e d e s t r i a n ” , face window = ” Face ” ; s t r i n g pedModel , faceModel , genderModel ; i n t webcamDevice = 0 ; string videoFile = ” ” ; b o o l webcam = f a l s e ; bool video = f a l s e ; bool capture = f a l s e ; bool c a l i b r a t i o n = f a l s e ; b o o l verbose = f a l s e ; f l o a t d e p t h F a c t o r = 1 . 3 9 , d i s t a n c e 1 = 300;
36 37 38
Mat c u r r e n t f r a m e ; i n t r o i x = 0 , r o i y = 0;
39 40 41
/ / S p e c i f i c v a r i a b l e s which can be changed based on i n p u t / / −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
41
42
42 43 44 45 46
A Programma code
/ / Length v a r i a b l e s i n t avgFemaleLength = 166; i n t avgMaleLength = 180; i n t avgBoyLength = 120; i n t a v g G i r l L e n g t h = 118;
47 48 49 50 51 52 53 54 55 56
/ / D e t e c t o r parameters i n t pedMargin = 3 0 ; i n t pedOverlap = 8 ; i n t faceOverlap = 5; i n t genderOverlap = 8 ; f l o a t pedIncrease = 1 . 0 5 ; f l o a t faceIncrease = 1.05; f l o a t genderIncrease = 1 . 0 1 ; / / −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
57 58 59
63
/ / F u n c t i o n t o r e g i s t e r mouse b u t t o n a c t i o n s / / When t h e l e f t mousebutton i s used , / / t h e c u r r e n t p o s i t i o n on t h e image i s saved ( x , y ) v o i d on mouse ( i n t event , i n t x , i n t y , i n t f l a g , v o i d ∗ param )
64
{
60 61 62
/ / A c t i o n when l e f t b u t t o n i s c l i c k e d i f ( event == CV EVENT LBUTTONDOWN)
65 66
{
67
roi x = x; roi y = y;
68 69
}
70 71
}
72
78
/ / F u n c t i o n t o c a l i b r a t e t h e camera / / C a l l i b r a t i o n needs some arguments / / 1 ) Size o f o b j e c t i n r e a l l i f e / / 2) Distance to o b j e c t f i r s t time / / 3 ) D i s t a n c e t o o b j e c t second t i m e v o i d c a l i b r a t e C a m e r a ( VideoCapture i n p u t v i d e o )
79
{
73 74 75 76 77
80 81
string input ; f l o a t d i s t a n c e 2 = 411 , basePoint1 = 0 , basePoint2 = 390;
82 83 84 85 86 87 88 89 90 91 92
c o u t << ” C a l i b r a t i o n w i z a r d ” << e n d l ; c o u t << ” ################### ” << e n d l ; c o u t << ” D i s t a n c e t o l o w e s t p a r t o f camera angle : ” ; c i n >> i n p u t ; distance1 = a t o f ( input . c s t r ( ) ) ; c o u t << ” D i s t a n c e 1 = ” << d i s t a n c e 1 << e n d l ; c o u t << ” D i s t a n c e t o h i g h e s t p a r t o f f l o o r : ” << e n d l ; c i n >> i n p u t ; distance2 = a t o f ( input . c s t r ( ) ) ; c o u t << ” D i s t a n c e 2 = ” << d i s t a n c e 2 << e n d l ;
93 94 95 96 97 98 99
/ / Now d i s p l a y a frame / / I f e n t e r i s pressed , t a k e a new frame / / when mousebutton i s c l i c k e d , p o s i t i o n o f i t bool basePointset1 = f a l s e ; bool basePointset2 = f a l s e ;
w i l l be saved
A Programma code
43
namedWindow ( pedestrian window , WINDOW AUTOSIZE) ; setMouseCallback ( pedestrian window , on mouse ) ;
100 101 102 103
while ( ! basePointset1 | ! basePointset2 )
104
{ i n p u t v i d e o >> c u r r e n t f r a m e ; i n t key = 0 ;
105 106 107
110
imshow ( pedestrian window , c u r r e n t f r a m e ) ; key = waitKey ( 0 ) ; i f ( key == 105)
111
{
108 109
i f ( ! basePointset1 )
112
{
113
basePoint1 = r o i y ; c o u t << ” Y = ” << basePoint1 << e n d l ; basePointset1 = tr ue ;
114 115 116
}
117 118
else
119
{ basePoint2 = r o i y ; c o u t << ” Y = ” << basePoint2 << e n d l ; basePointset2 = tr ue ;
120 121 122
}
123
}
124
}
125 126
c o u t << ” C a l c u l a t i n g t h e t r a n s f o r m a t i o n f a c t o r s . . . ” << e n d l ; destroyWindow ( p e d e s t r i a n w i n d o w ) ; d e p t h F a c t o r = ( d i s t a n c e 2 − d i s t a n c e 1 ) / ( basePoint1 − basePoint2 ) ; c o u t << d e p t h F a c t o r << e n d l ;
127 128 129 130 131
return ;
132 133
}
134 135
i n t main ( i n t argc , c o n s t char ∗∗ argv )
136
{
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
/ / Check i f arguments are g i v e n c o r r e c t i f ( argc == 1 ) { c o u t << ” Usage o f d e t e c t i o n & c l a s s i f i c a t i o n s o f t w a r e : ” << argv [ 0 ] << e n d l ; c o u t << ” #### Model f i l e s #### ” << e n d l ; c o u t << ” −pedModel ” << e n d l ; c o u t << ” −faceModel ” << e n d l ; c o u t << ” −genderModel ” << e n d l ; c o u t << ” #### Webcam parameters ( i f no v i d e o ) #### ” << e n d l ; c o u t << ” −webcam number < d e f a u l t = ” << webcamDevice << ”> ” << e n d l ; c o u t << ” − c a l i b r a t e ( w i l l g i v e a c a l l i b r a t i o n w i z a r d ) ” << e n d l ; c o u t << ” #### Video parameters ( i f no webcam ) #### ” << e n d l ; c o u t << ”−v i d e o < v i d e o f i l e >” << e n d l ; c o u t << ” #### A d d i t i o n a l model parameters #### ” << e n d l ; c o u t << ” [− pedOverlap < d e f a u l t = ” << pedOverlap << ” >] ” << e n d l ; c o u t << ” [− f a c e O v e r l a p < d e f a u l t = ” << f ac e O ve r l a p << ” <] ” << e n d l ; c o u t << ” [− genderOverlap < d e f a u l t = ” << genderOverlap << ” <] ” << e n d l ; c o u t << ” [− pedIncrease < d e f a u l t = ” << pedIncrease << ” <] ” << e n d l ; c o u t << ” [− f a c e I n c r e a s e < d e f a u l t = ” << f a c e I n c r e a s e << ” >] ” << e n d l ; c o u t << ” [− genderIncrease < d e f a u l t = ” << genderIncrease << ” >] ” << e n d l ; c o u t << ” #### A d d i t i o n a l parameters ### ” << e n d l ;
44
A Programma code
c o u t << ”−v ( w i l l v i s u a l i z e more than n o r m a l l y ) ” << e n d l ; c o u t << ”−c a p t u r e ( w i l l c a p t u r e t h e images from t h e webcam o r v i d e o f i l e ) ” << e n d l ; return 0;
158 159 160 161 162
}
163 164 165 166 167 168
/ / Read t h e v a l u e s o f t h e arguments f o r ( i n t i = 1 ; i < argc ; i ++ )
{ i f ( ! strcmp ( argv [ i ] , ”−pedModel ” ) )
{ pedModel = argv [++ i ] ;
169 170
}
171
e l s e i f ( ! strcmp ( argv [ i ] , ”−faceModel ” ) )
172
{ faceModel = argv [++ i ] ;
173 174
}
175
e l s e i f ( ! strcmp ( argv [ i ] , ”−genderModel ” ) )
176
{ genderModel = argv [++ i ] ;
177 178
}
179
e l s e i f ( ! strcmp ( argv [ i ] , ”−webcam ” ) )
180
{ webcamDevice = a t o i ( argv [++ i ] ) ; webcam = t r u e ; video = f a l s e ;
181 182 183 184
}
185
e l s e i f ( ! strcmp ( argv [ i ] , ”−v i d e o ” ) )
186
{ v i d e o F i l e = argv [++ i ] ; video = t r u e ; webcam = f a l s e ;
187 188 189 190
}
191
e l s e i f ( ! strcmp ( argv [ i ] , ”− c a l i b r a t e ” ) )
192
{ calibration = true ;
193 194
}
195
e l s e i f ( ! strcmp ( argv [ i ] , ”−v ” ) )
196
{ verbose = t r u e ;
197 198
}
199
e l s e i f ( ! strcmp ( argv [ i ] , ”−c a p t u r e ” ) )
200
{ capture = true ;
201 202
}
203
e l s e i f ( ! strcmp ( argv [ i ] , ”−pedOverlap ” ) )
204
{ pedOverlap = a t o i ( argv [++ i ] ) ;
205 206
}
207
e l s e i f ( ! strcmp ( argv [ i ] , ”−f a ce O v er l a p ” ) )
208
{ f a c e O v e r l a p = a t o i ( argv [++ i ] ) ;
209 210
}
211
e l s e i f ( ! strcmp ( argv [ i ] , ”−genderOverlap ” ) )
212
{ genderOverlap = a t o i ( argv [++ i ] ) ;
213 214
}
215
e l s e i f ( ! strcmp ( argv [ i ] , ”−pedIncrease ” ) )
A Programma code
{
216
pedIncrease = a t o f ( argv [++ i ] ) ;
217
}
218 219
e l s e i f ( ! strcmp ( argv [ i ] , ”−f a c e I n c r e a s e ” ) )
220
{ f a c e I n c r e a s e = a t o f ( argv [++ i ] ) ;
221
}
222 223
e l s e i f ( ! strcmp ( argv [ i ] , ”−genderIncrease ” ) )
224
{ genderIncrease = a t o f ( argv [++ i ] ) ;
225
}
226
}
227 228 229 230 231 232 233 234
/ / Load t h e p e d e s t r i a n model i n t o t h e model c o n t a i n e r i f ( ! p e d e s t r i a n . l o a d ( pedModel ) ) { c o u t << ” E r r o r l o a d i n g t h e p e d e s t r i a n model from t h e p r o v i d e d model f i l e ! ” << e n d l ; r e t u r n −1; };
235 236 237 238 239 240 241
/ / Load t h e f a c e model i n t o t h e model c o n t a i n e r i f ( ! f a c e . l o a d ( faceModel ) ) { c o u t << ” E r r o r l o a d i n g t h e f a c e model from t h e p r o v i d e d model f i l e ! ” << e n d l ; r e t u r n −1; };
242 243 244 245 246 247 248
/ / Load t h e gender model i n t o t h e model c o n t a i n e r i f ( ! gender . l o a d ( genderModel ) ) { c o u t << ” E r r o r l o a d i n g t h e gender model from t h e p r o v i d e d model f i l e ! ” << e n d l ; r e t u r n −1; };
249
258
/ / Open t h e v i d e o c a p t u r e i n t e r f a c e ; VideoCapture i n p u t v i d e o ; i f ( webcam ) i n p u t v i d e o = webcamDevice ; else input video = videoFile ; i f ( ! i n p u t v i d e o . isOpened ( ) ) { c o u t << ” Camera cannot be opened c o r r e c t l y . ” << e n d l ; r e t u r n −1;
259
}
250 251 252 253 254 255 256 257
260 261 262 263 264 265
/ / C o n f i g u r e parameters f o r w r i t i n g images from v i d e o v e c t o r parameters ; parameters . push back ( CV IMWRITE PNG COMPRESSION ) ; parameters . push back ( 0 ) ; i f ( calibration ) calibrateCamera ( i n p u t v i d e o ) ;
266
270
/ / Parameters f o r making v i d e o VideoWriter output video ; VideoWriter output video2 ; i f ( capture )
271
{
267 268 269
272 273
double w i d t h = i n p u t v i d e o . g e t ( CV CAP PROP FRAME WIDTH ) ; double h e i g h t = i n p u t v i d e o . g e t ( CV CAP PROP FRAME HEIGHT ) ;
45
46
A Programma code
274
o u t p u t v i d e o . open ( ” c a p t u r e . a v i ” , CV FOURCC( ’D ’ , ’ I ’ , ’V ’ , ’X ’ ) , 15 , cvSize ( ( i n t ) width , ( i n t ) h e i g h t ) ) ; o u t p u t v i d e o 2 . open ( ” c a p t u r e t r a c k . a v i ” , CV FOURCC( ’D ’ , ’ I ’ , ’V ’ , ’X ’ ) , 15 , cvSize ( ( i n t ) width , ( i n t ) h e i g h t ) ) ;
275 276 277 278 279
/ / Check i f t h e v i d e o s were opened f o r w r i t i n g i f ( ! o u t p u t v i d e o . isOpened ( ) )
280 281
{
282
c e r r << ” Could n o t c r e a t e f i r s t o u t p u t v i d e o . ” ; r e t u r n −1;
283 284
}
285 286
i f ( ! o u t p u t v i d e o 2 . isOpened ( ) )
287
{
288
c e r r << ” Could n o t c r e a t e second o u t p u t v i d e o . ” ; r e t u r n −1;
289 290
}
291 292
}
293 294 295 296 297 298 299 300 301 302 303 304 305
/ / −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− / / START ACTUAL ALGORITM / / −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− / / Loop over each image i n t h e v i d e o o r webcam image stream and perform / / detections for ( ; ; )
{ / / Read i n t h e f i r s t image i n p u t v i d e o >> c u r r e n t f r a m e ; / / Save c u r r e n t frame i n f i r s t v i d e o f i l e i f ( capture ) o u t p u t v i d e o << c u r r e n t f r a m e ;
306 307 308 309 310 311 312 313 314 315 316 317
/ / Perform check i f a n y t h i n g goes wrong w i t h t h e v i d e o c a p t u r e o r i f t h e / / v i d e o f i l e i s a t t h e end i f ( c u r r e n t f r a m e . empty ( ) ) { i f ( webcam ) c o u t << ” L a s t frame grabbed was empty , something might be wrong ” ” w i t h t h e d e v i c e . ” << e n d l ; else c o u t << ” L a s t frame was grabbed , c l o s i n g t h e program ” << e n d l ; break ;
}
318 319 320 321 322 323 324 325
/ / −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− / / PREPARE FOR DETECTION / / −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− / / S p e c i f i c v a r i a b l e s f o r t h e a c t u a l d e t e c t i o n phase v e c t o r o b j e c t s ; Mat f r a m e g r a y ; Size c u r r e n t s i z e = c u r r e n t f r a m e . s i z e ( ) ;
326 327 328 329 330 331
// // // // //
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− PREPROCESSING STEP
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Convert t h e i n p u t frame t o g r a y s c a l e image and a p p l y l i g h t n i n g n o r m a l i z a t i o n using histogram e q u i l i z a t i o n
A Programma code
332 333
47
c v t C o l o r ( c u r r e n t f r a m e , frame gray , CV BGR2GRAY ) ; e q u a l i z e H i s t ( frame gray , f r a m e g r a y ) ;
334 335 336 337 338 339
// // // // //
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− PERFORM THE ACTUAL DETECTIONS
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− PHASE 1 : D e t e c t p e d e s t r i a n
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
340 341 342 343
/ / D e t e c t p e d e s t r i a n i n t h e g i v e n image based on i n p u t parameters p e d e s t r i a n . d e t e c t M u l t i S c a l e ( frame gray , o b j e c t s , pedIncrease , pedOverlap , 0 , Size ( 1 0 0 , 5 0 ) , Size ( c u r r e n t s i z e . width , c u r r e n t s i z e . h e i g h t ) ) ;
344
346
/ / Loop over found p e d e s t r i a n s i n image f o r ( u i n t j = 0 ; j < o b j e c t s . s i z e ( ) ; j ++ )
347
{
345
348 349 350 351
/ / Some needed v a r i a b l e s l a t e r on Mat cuttedPed , cuttedPedHead ; v e c t o r detectedFaces , detectedGender ; b o o l male = f a l s e ;
352 353 354 355 356 357 358
/ / Save p o s i t i o n o f c u r r e n t o b j e c t i n v a r i a b l e s / / and add e x t r a margin i n l e n g t h i n t xPositionPed = objects [ j ] . x ; i n t y P o s i t i o n P e d = o b j e c t s [ j ] . y − pedMargin ; i n t widthPed = o b j e c t s [ j ] . w i d t h ; i n t heightPed = o b j e c t s [ j ] . h e i g h t + ( pedMargin ∗ 2) ;
359 360 361 362 363 364
/ / Check i f s t i l l w i t h i n window i f ( yPositionPed < 0) yPositionPed = 0; i f ( heightPed + y P o s i t i o n P e d > c u r r e n t s i z e . h e i g h t ) heightPed = ( c u r r e n t s i z e . h e i g h t − y P o s i t i o n P e d ) ;
365 366 367 368 369 370
/ / Draw red r e c t a n g l e around found p e d e s t r i a n r e c t a n g l e ( c u r r e n t f r a m e , P o i n t ( xPositionPed , y P o s i t i o n P e d ) , P o i n t ( x P o s i t i o n P e d + widthPed , y P o s i t i o n P e d + heightPed ) , S c a l a r ( 0 , 0 , 255) , 1 ) ;
371 372 373 374 375 376 377
/ / Cut o u t t h e p e d e s t r i a n d e t e c t i o n f o r n e x t d e t e c t o r c u r r e n t f r a m e ( Rect ( xPositionPed , yPositionPed , widthPed , heightPed ) ) . copyTo ( cuttedPed ) ; c u r r e n t f r a m e ( Rect ( xPositionPed , yPositionPed , widthPed , heightPed ∗ 0 . 3 ) ) . copyTo ( cuttedPedHead ) ; Size p e d e s t r i a n S i z e = cuttedPed . s i z e ( ) ;
378 379 380 381
/ / V i s u a l i z e t h e c u t t e d p e d e s t r i a n and t h e f u l l image i f verbose i f ( verbose )
{ imshow ( window name , c u r r e n t f r a m e ) ; imshow ( pedestrian window , cuttedPed ) ; waitKey ( 0 ) ;
382 383 384
}
385 386 387 388 389
// // // //
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− PHASE 2 : D e t e c t f a c e
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Try t o d e t e c t f a c e i n c u t t e d p e d e s t r i a n image
48
A Programma code
f a c e . d e t e c t M u l t i S c a l e ( cuttedPedHead , detectedFaces , f a c e I n c r e a s e , faceOverlap , 0 ) ; i f ( detectedFaces . s i z e ( ) > 0 && verbose ) c o u t << ” Faces d e t e c t e d : ” << detectedFaces . s i z e ( ) << e n d l ;
390 391 392 393 394
396
/ / Loop over d e t e c t e d f a c e s ( Can i t o n l y be one ? ) f o r ( u i n t k = 0 ; k < detectedFaces . s i z e ( ) ; k++ )
397
{
395
Mat cuttedFace ;
398 399
/ / Draw red r e c t a n g l e around found p e d e s t r i a n w i t h f a c e / / This gives less v i s u a l i z a t i o n s i f ( ! verbose ) r e c t a n g l e ( c u r r e n t f r a m e , P o i n t ( xPositionPed , y P o s i t i o n P e d ) , P o i n t ( x P o s i t i o n P e d + widthPed , y P o s i t i o n P e d + heightPed ) , S c a l a r ( 0 , 0 , 255) , 1 ) ;
400 401 402 403 404 405 406
/ / Save p o s i t i o n o f c u r r e n t f a c e s i n v a r i a b l e s / / and add e x t r a margin i n w i d t h and l e n g t h i n t extraWidth = 30; i n t extraHeight = 30; i n t xPosFace = x P o s i t i o n P e d + detectedFaces [ k ] . x − e x t r a W i d t h ; i n t yPosFace = y P o s i t i o n P e d + detectedFaces [ k ] . y − e x t r a H e i g h t ; i n t widthFace = detectedFaces [ k ] . w i d t h + e x t r a W i d t h ∗ 2; i n t heightFace = detectedFaces [ k ] . h e i g h t + e x t r a H e i g h t ∗ 2;
407 408 409 410 411 412 413 414 415
/ / Check i f we are s t i l l i n s i d e our frame i f ( xPosFace < 0 ) xPosFace = 0 ; i f ( yPosFace < 0 ) yPosFace = 0 ; i f ( xPosFace + widthFace > c u r r e n t s i z e . w i d t h ) widthFace = ( c u r r e n t s i z e . w i d t h − xPosFace ) ; i f ( yPosFace + heightFace > c u r r e n t s i z e . h e i g h t ) heightFace = ( c u r r e n t s i z e . h e i g h t − yPosFace ) ;
416 417 418 419 420 421 422 423 424 425
/ / P r i n t o u t any i n f o r m a t i o n i f ( verbose )
426 427
{
428
c o u t << ” Face l o c a t i o n : x : ” << xPosFace << ” y : ” << yPosFace << ” w i d t h : ” << widthFace << ” h e i g h t : ” << heightFace << e n d l ; c o u t << ” Face l o c a t i o n w i t h o u t ped : x : ” << detectedFaces [ k ] . x << ” y : ” << detectedFaces [ k ] . y << ” w i d t h : ” << widthFace << ” h e i g h t : ” << heightFace << e n d l ;
429 430 431 432 433 434 435
r e c t a n g l e ( cuttedPed , P o i n t ( detectedFaces [ k ] . x , detectedFaces [ k ] . y )
436
, 437 438 439 440
P o i n t ( detectedFaces [ k ] . x + detectedFaces [ k ] . width , detectedFaces [ k ] . y + detectedFaces [ k ] . h e i g h t ) , S c a l a r ( 0 , 255 , 0 ) , 1 ) ; imshow ( pedestrian window , cuttedPed ) ; / / waitKey ( 0 ) ;
441 442 443 444 445 446
/ / Draw r e c t a n g l e around rectangle ( current frame , P o i n t ( xPosFace S c a l a r ( 0 , 255 ,
f a c e i n green P o i n t ( xPosFace , yPosFace ) , + widthFace , yPosFace + heightFace ) , 0) , 1) ;
A Programma code
49
/ / V i s u a l i s e t h e new drawn r e c t a n g l e imshow ( window name , c u r r e n t f r a m e ) ; / / waitKey ( 0 ) ;
447 448 449
}
450 451 452 453
/ / Cut o u t t h e p e d e s t r i a n d e t e c t i o n f o r n e x t d e t e c t o r c u r r e n t f r a m e ( Rect ( xPosFace , yPosFace , widthFace , heightFace ) ) . copyTo ( cuttedFace ) ;
454 455 456 457
/ / V i s u a l i z e the cutted face i f ( verbose )
{ imshow ( face window , cuttedFace ) ; waitKey ( 0 ) ;
458 459
}
460 461
//
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 462 463
/ / PHASE 3 : Determine l e n g t h o f p e d e s t r i a n //
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 464 465 466 467 468 469 470 471 472 473 474 475 476 477
/ / F u n c t i o n t o determine t h e a c t u a l l e n g t h o f t h e / / found p e d e s t r i a n / / T h i s e s t i m a t i o n i s based on t h e p o s i t i o n o f t h e / / f e e t of the pedestrian / / ( t h i s i s t h e r e f e r e n c e ) and t h e amount o f p i x e l s / / from t h e r e t i l l h i s / her / / head . Based on mean age / l e n g t h s t a t i s t i c s t h e / / person i s c a t e g o r i s e d by / / the r e s u l t . / / The p o s i t i o n o f t h e f e e t i s found by t a k i n g a p r e d e f i n e d / / margin from t h e / / a c t u a l d e t e c t i o n ( r e c t a n g l e ) and so i s t h e head . Size pedSize = cuttedPed . s i z e ( ) ; i n t pedHeight = pedSize . h e i g h t ∗ 0 . 9 ;
478
484
/ / Translate the p i x e l size to r e a l world size via / / translation factors f l o a t depth = ( d e p t h F a c t o r ∗ ( c u r r e n t s i z e . h e i g h t − ( y P o s i t i o n P e d + heightPed ) ) ) + d i s t a n c e 1 ; f l o a t a c t u a l S i z e P e d = ( depth ∗ pedHeight ) / 700; i f ( verbose )
485
{
479 480 481 482 483
c o u t << ” Lowest p a r t : ” << y P o s i t i o n P e d + heightPed << e n d l ; c o u t << ” From bottom t o f e e t : ” << c u r r e n t s i z e . h e i g h t − ( y P o s i t i o n P e d + heightPed ) << e n d l ; c o u t << ” P e d e s t r i a n depth : ” << depth << e n d l ; c o u t << ” A c t u a l p e d e s t r i a n s i z e : ” << a ct ua lS i ze Pe d << e n d l ;
486 487 488 489 490 491
}
492 493 494
//
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 495 496
/ / PHASE 4 : D e t e c t gender //
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 497 498 499 500
/ / For each d e t e c t e d face , t r y t o determine gender gender . d e t e c t M u l t i S c a l e ( cuttedFace , detectedGender , genderIncrease , genderOverlap , 0 ) ;
50
A Programma code
i f ( detectedGender . s i z e ( ) > 0 )
501
{
502
i f ( verbose ) c o u t << ” Male person d e t e c t e d ” << e n d l ;
503 504 505
/ / When a male person i s / / around f a c e rectangle ( current frame , P o i n t ( xPosFace Scalar (255 , 0 , male = t r u e ;
506 507 508 509 510 511
detected , draw b l u e r e c t a n g l e P o i n t ( xPosFace , yPosFace ) , + widthFace , yPosFace + heightFace ) , 0) , 1) ;
}
512 513
else
514
{ i f ( verbose ) c o u t << ” Female person d e t e c t e d ” << e n d l ;
515 516 517
/ / When a female person i s detected , draw p i n k r e c t a n g l e / / around f a c e r e c t a n g l e ( c u r r e n t f r a m e , P o i n t ( xPosFace , yPosFace ) , P o i n t ( xPosFace + widthFace , yPosFace + heightFace ) , S c a l a r ( 2 5 5 , 0 , 255) , 1 ) ; male = f a l s e ;
518 519 520 521 522 523
}
524 525
//
526
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− / / PHASE 5 : Guess t h e age by i t s gender and l e n g t h //
527 528
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− i f ( male )
529
{
530
i f ( a c t u a l S i z e P e d > avgMaleLength ∗ 0 . 8 )
531
{
532
p u t T e x t ( c u r r e n t f r a m e , ”Man” , P o i n t ( xPosFace + widthFace , yPosFace + heightFace ) , FONT HERSHEY COMPLEX SMALL, 0 . 8 , c v S c a l a r ( 2 5 5 , 0 , 0 ) , 1 , CV AA ) ; c o u t << ”Man d e t e c t e d ( age 12+) ” << e n d l ;
533 534 535 536
}
537 538
e l s e i f ( a c t u a l S i z eP ed > avgBoyLength ∗ 0 . 8 )
539
{ p u t T e x t ( c u r r e n t f r a m e , ” Boy ” , P o i n t ( xPosFace + widthFace , yPosFace + heightFace ) , FONT HERSHEY COMPLEX SMALL, 0 . 8 , c v S c a l a r ( 2 5 5 , 0 , 0 ) , 1 , CV AA ) ; c o u t << ” Boy d e t e c t e d ( age 6 −12) ” << e n d l ;
540 541 542 543
}
544 545
else
546
{ p u t T e x t ( c u r r e n t f r a m e , ” L i t t l e boy ” , P o i n t ( xPosFace + widthFace
547
, yPosFace + heightFace ) , FONT HERSHEY COMPLEX SMALL, 0 . 8 , c v S c a l a r ( 2 5 5 , 0 , 0 ) , 1 , CV AA ) ; c o u t << ” L i t t l e boy d e t e c t e d ( age < 6 ) ” << e n d l ;
548 549 550
}
551
c o u t << ” A c t u a l p e d e s t r i a n s i z e : ” << a ct ua lS i ze Pe d << e n d l ; / / waitKey ( 0 ) ;
552 553 554
}
555
else
A Programma code
51
{
556
i f ( a c t u a l S i ze P ed > avgFemaleLength ∗ 0 . 8 )
557
{
558
p u t T e x t ( c u r r e n t f r a m e , ”Woman” , P o i n t ( xPosFace + widthFace , yPosFace + heightFace ) , FONT HERSHEY COMPLEX SMALL, 0 . 8 , c v S c a l a r ( 2 5 5 , 0 , 2 5 5 ) , 1 , CV AA ) ; c o u t << ”Woman d e t e c t e d ( age 12+) ” << e n d l ;
559 560 561 562
}
563 564
e l s e i f ( a c t u al Si z eP ed > a v g G i r l L e n g t h ∗ 0 . 8 )
565
{ p u t T e x t ( c u r r e n t f r a m e , ” G i r l ” , P o i n t ( xPosFace + widthFace , yPosFace + heightFace ) , FONT HERSHEY COMPLEX SMALL, 0 . 8 , c v S c a l a r ( 2 5 5 , 0 , 2 5 5 ) , 1 , CV AA ) ; c o u t << ” G i r l d e t e c t e d ( age 6 −12) ” << e n d l ;
566 567 568 569
}
570 571
else
572
{ putText ( current frame , ” L i t t l e
573
g i r l ” , P o i n t ( xPosFace +
widthFace , yPosFace + heightFace ) , FONT HERSHEY COMPLEX SMALL, 0 . 8 , c v S c a l a r ( 2 5 5 , 0 , 2 5 5 ) , 1 , CV AA ) ; c o u t << ” L i t t l e g i r l d e t e c t e d ( age < 6 ) ” << e n d l ;
574 575 576
}
577
c o u t << ” A c t u a l p e d e s t r i a n s i z e : ” << a ct ua lS i ze Pe d << e n d l ; / / waitKey ( 0 ) ;
578 579
}
580
}
581
}
582
/ / −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− / / VISUALIZE THE ACTUAL DETECTION / / −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
583 584 585 586
/ / Show t h e r e s u l t o f a l l t h e d e t e c t o r s imshow ( window name , c u r r e n t f r a m e ) ;
587 588 589
/ / Save t h e t r a c k e d image t o t h e new i f ( capture ) o u t p u t v i d e o 2 << c u r r e n t f r a m e ;
590 591 592 593
i n t key = waitKey ( 5 ) ; i f ( key == 27 ) { break ; }
594 595
}
596 597
return 0;
598 599
} Listing A.1: Volledige algoritme
FACULTEIT INDUSTRIELE INGENIEURSWETENSCHAPPEN CAMPUS DE NAYER (@Thomas More) Jan De Nayerlaan 5 2860 SINT-KATELIJNE-WAVER, België tel. + 32 15 31 69 44 [email protected] www.iiw.kuleuven.be
