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 <fstream >
# i n c l u d e <iostream >
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 <opencv2 / core / core . hpp>
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 <p e d e s t r i a n m o d e l . xml>” << e n d l ;
c o u t << ” −faceModel <face model . xml>” << e n d l ;
c o u t << ” −genderModel <gender model . xml>” << 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 <i n t > 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 <Rect> 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 <Rect> 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

2-Megapixel Mini-Dome netwerkcamera IDC-862 HD

LG G Pad 8.3 V500 Wifi Black

Gedicht ALS ik ben overleden door Mieke van den Berg

001282384-an-01-nl-KURZ D LINK DCS 2330L E WLAN N KAMERA

Panasonic 360° Camera - Support

Lied 3 Gin Gezicht

M.ZUIKO DIGITAL ED 40‑150mm 1:2.8 PRO

Tips om rugpijn te verlichten/voorkomen bij AV- technici.

LAATSTE TEKENING

complete workshopoverzicht januari - juni 2015

kinderrechtelijke aspecten van de gewijzigde Transgenderwet