Projet de Physique P6-3

STPI/P6-3/2009 – 003

Reconstruction de la 3D à partir d'images 2D

Etudiants :
Gabriel HAUTREUX Floriane HEDOUIN
Mélanie LEMAIRE Emilie LEVEQUE
Kelly Pamela MBOLAMENA Charline PENNEQUIN

Enseignant-responsable du projet :
Jérôme YON
2
Date de remise du rapport : 18/06/2010

Référence du projet : STPI/P6-3/2009 – 003

Intitulé du projet : Reconstitution de la 3D à partir d’images 2D.

Type de projet : Expérimental

Informatique et mathématique

Objectifs du projet :

Ce projet a été traité par un autre groupe l’année dernière. L'objectif de celui-ci était
d'obtenir une reproduction 3D d'un objet à partir d'une image 2D de cet objet par projection
de stries. Il a donc fallu qu'il obtienne les données nécessaires pour avoir la reproduction 3D,
c'est-à-dire les coordonnées des points de l'image sans l'objet puis avec l'objet. Mais le
groupe a pu constater que l'obtention de ces dernières était à la fois fastidieuse et longue.
Nous avons donc pris pour objectif d’essayer d’automatiser ces obtentions de données pour
gagner en rapidité.
De plus, notre projet a plusieurs autres objectifs, à savoir un volet expérimental avec
l’acquisition d’images, le test de ces images, la mise au point de programmes informatiques,
et bien sûr l’interprétation des différents résultats obtenus, dans le but d’une reconstruction
3D.

3
 TABLE DES MATIERES

1. Introduction.........................................................................................................................5
2. Méthodologie et Organisation du travail..............................................................................6
3. Travail réalisé et résultats...................................................................................................7
3.1. Méthodes existantes pour la reconstruction d’images 3D..............................................7
3.1.1. L’auto-calibrage.....................................................................................................7
3.1.2. Méthode des ombres.............................................................................................9
3.1.3. Notre méthode: la corrélation d'images...............................................................10
3.2. Analyse mathématique................................................................................................10
3.2.1. Le produit de convolution.....................................................................................10
3.2.2. Projections...........................................................................................................13
4. Expérience et résultats......................................................................................................14
4.1. Dispositif expérimental................................................................................................14
4.2. Logiciels utilisés...........................................................................................................15
4.2.1. OpenCV...............................................................................................................15
4.2.2. Scilab...................................................................................................................16
4.2.3. Blender................................................................................................................16
4.3. Compte-rendu de l’expérience.....................................................................................20
4.3.1. Compte-rendu de l’expérience réalisée................................................................20
4.3.2. Récupération des données de l’expérience.........................................................20
4.3.3. Résultats:.............................................................................................................21
4.3.4. Analyse des résultats:..........................................................................................22
5. Conclusions et perspectives..............................................................................................25
6. Bibliographie.....................................................................................................................26
7. Table des illustrations........................................................................................................27
8. Annexes............................................................................................................................28
8.1. Projections mathématiques.........................................................................................28
8.2. Utilisation du programme Patern-Matching..................................................................30
8.3. Exemple de programme avec Scilab...........................................................................31
8.4. Programme sous Scilab permettant d’obtenir le maillage des points...........................32
8.5. Script pour les facettes dans Blender:.........................................................................34

4
1. INTRODUCTION

Dans le cadre de notre projet de physique réalisé au cours de notre 4ème semestre,
nous avons étudié la représentation 3D à partir d'un objet 2D par projection d’images sur un
fond blanc. Ce projet est donc centré sur le traitement d'images et le relief.

Il est important de savoir que le traitement d'images 3D est toujours en phase de

recherche, dans le but d'améliorer la qualité de l'image obtenue.

En effet, ce traitement d'images a de nombreuses applications telles que la

réalisation et la projection de films 3D, les échographies, les jeux vidéos ...

Nous avons remarqué l'existence d'un nombre important de méthodes différentes en

relation avec notre sujet. Ainsi, nous allons en développer quelques-unes dans ce dossier.
Cependant, nous en avons choisi une plus spécialement que nous avons approfondie : la
corrélation d'image.

Ce sujet a déjà été traité l'année dernière, en effet, le but était d'obtenir le relief d'un
objet photographié sur un fond quadrillé. Cependant, les récupérations de données se sont
révélées fastidieuses et longues, nous cherchons donc à améliorer cet aspect, non pas sur
les résultats obtenus, mais plutôt sur les méthodes utilisées pour l'acquisition des données
extraites des images. En effet, il a fallu utiliser une méthode permettant d’automatiser
l'acquisition des données nécessaires pour la reproduction 3D à partir d’images 2D.

Nous allons donc expliquer les différentes expériences effectuées ainsi que les
résultats et conclusions que nous avons pu en tirer, afin de mieux comprendre le projet et,
pourquoi pas, l'améliorer par la suite.

5
2. MÉTHODOLOGIE ET ORGANISATION DU TRAVAIL

Lorsque nous nous sommes penchés sur le sujet, nous avons commencé par lire le
dossier du groupe de l’année précédente dans le but d’orienter nos recherches. Notre
principal objectif était d’améliorer la méthode utilisée par le groupe précédent, notamment au
point de vue de l'acquisition des données.
Dans cette optique, nous avons donc organisé notre travail autour de recherches de
méthodes de reconstruction 3D. Ensuite, nous avons programmé deux séances
d’expérience nous servant à créer des exemples à analyser. Ces analyses se sont faites
grâce à plusieurs logiciels.
Notre sujet a donc nécessité des recherches dans des domaines différents. En effet,
nous avons découpé nos recherches en plusieurs aspects principaux tels que l’aspect
mathématique, l’aspect recherche de méthodes et de logiciels, l’aspect informatique (avec
l’écriture et la compréhension de programmes) et l’aspect expérimental.
Le travail a été réparti de façon équitable mais aussi en fonction de l'attrait des
personnes par rapport à l'un des aspects étudiés.
En ce qui concerne l’expérience et l’écriture du dossier, tout le groupe a participé à la
tâche.

Illustration 1: Répartition des tâches pour les membres du groupe

6
3. TRAVAIL RÉALISÉ ET RÉSULTATS

3.1. Méthodes existantes pour la reconstruction d’images 3D

3.1.1. L’auto-calibrage

L'auto-calibrage permet de déterminer des informations tridimensionnelles (distances,

positions) d'une scène statique à partir d'une série d'images bidimensionnelles (il en faut au
moins 2).

Scène statique

Cette méthode s'appuie sur le fait qu'une image dépende de la structure de la scène
et de la géométrie de la caméra, sachant que la géométrie d'une caméra se définit, d'une
part, par sa géométrie externe (position et orientation) et, d'autre part, par sa géométrie
interne ( distance focale, taille des pixels, etc… ).

Elle consiste à prendre plusieurs clichés de la scène (une fois l'orientation choisie, la
caméra ne doit bouger que dans un plan et sa géométrie interne doit être la même pour
toutes les prises de vues) et mettre les différentes images en correspondance, en d'autres
termes « repérer » les points appartenant aux mêmes objets, pour avoir des informations sur
la structure de la scène.

Suivant les conditions de prise de vue, on peut obtenir soit une reconstruction affine,
soit une reconstruction projective lesquelles donnent une structure globale de la scène qui se
rapproche de la réalité mais qui ne tient pas compte des distances et des angles. En effet,
ces transformations permettent seulement de calculer les propriétés qui leurs sont
invariantes; par exemple, la reconstruction affine ne calcule que les rapports de distance
entre 3 points colinéaires.

7
 Structure obtenue après
reconstruction

Pour lever ces indéterminations et obtenir les propriétés euclidiennes de la scène

(parallélisme, angles, rapports de longueurs, etc.), on fait intervenir les données sur la
structure de la scène et la géométrie de la caméra.
Pour des questions pratiques, on privilégie les hypothèses faites sur la géométrie interne des
caméras à savoir, d'une part, le fait que les paramètres internes comme la taille des pixels
soient invariants, et , d'autre part, le fait que le zoom soit le même entre deux prises de vue.
C'est d'ailleurs de là que vient le terme d'auto-calibrage.
Pour que la scène reconstruite se rapproche un maximum de la réalité, on peut compléter
l'étude en faisant intervenir les connaissances de la structure de la scène (rapport de deux
distances, contraintes entre deux droites ou deux plans) et les connaissances de la
géométrie externe de la caméra.

Structure après auto-calibrage

* Images tirées du Autocalibrage multi-vues d'une distance focale et mouvements critiques

associés
"Benoît Bocquillon, Adrien Bartoli, Pierre Gurdjos, Alain Crouzil".

8
 3.1.2. Méthode des ombres

Une équipe de chercheurs de l'Université de York a mis en place un nouvel outil de

modélisation de visage 3D à partir d'une image 2D. Pour ce faire, ils ont choisi de combiner
deux méthodes : Le morphing 3D et l'étude des ombres dans les images.

Le morphing 3D est une méthode qui s'applique selon le principe «tous les visages
sont plus ou moins similaires». A partir d'une banque de données contenant des formes de
visages, elle compare la photographie prise avec un modèle qui lui est proche, tout en
réduisant les erreurs entre les deux images. Cette technique est assez longue donc souvent
effectuée par ordinateur. De plus, le principal défaut de cette méthode est qu'elle ne peut pas
reconstituer des caractéristiques atypiques qu'elle n'aurait pas rencontrées avant.

L'étude des ombres permet d'utiliser des données comme le changement de

luminosité et la direction de surfaces des visages. Elle permet, ainsi, une reconstitution plus
précise des détails tels que les rides ou encore les formes du nez.

Les deux méthodes prises séparément permettent à elles seules de reconstituer les
visages. Cependant, la précision des images obtenues par leur utilisation simultanées
augmentent exponentiellement.

9
Un exemple de reconstitution faciale par cette méthode:

3.1.3. Notre méthode: la corrélation d'images

La corrélation est une méthode permettant de comparer, par exemple, deux images.
Néanmoins, elle est aussi utilisée dans le traitement du signal, en statistique et dans d'autres
domaines.
Dans notre sujet, la corrélation est utilisée pour déterminer le déplacement d’une
image par rapport à une autre, suite à l’ajout d’un objet. Pour ce faire, l'image est
décomposée en plusieurs petites « boites » (une case d'un échiquier par exemple), c'est le
déplacement de chaque « boite » qui déterminera l'épaisseur du fragment d'objet contenu
dans cette « boite ».
En effet, la comparaison des deux images (l’une sans et l’une avec l’objet) permet de
repérer les déplacements possibles de points de l’image et ainsi, de déterminer les vecteurs
déplacements. Concrètement, la corrélation est le résultat du repérage de tous ces
déplacements dans chaque boîte. Pour cela, la corrélation analyse la similarité de deux
motifs, d’où le lien avec le produit de convolution présenté ci-après.
Une simple projection grâce aux vecteurs de déplacement nous permettra de définir
la profondeur nous permettant de recréer la 3D.

3.2. Analyse mathématique

3.2.1. Le produit de convolution

1 Définition

Le produit de convolution est une méthode mathématique qui consiste à « mélanger

les deux formes de deux fonctions ».

10
Il est défini par la formule suivante:

(f*g)(x)= ∫f(x-t)g(t)dt=∫f(t)g(x-t)dt.
Ce produit présente plusieurs propriétés de calculs telles que la commutativité, la
distributivité sur l'addition, l'associativité, ou la compatibilité avec les translations.

Cet outil est utilisé dans de nombreux domaines tels que le traitement du signal, la
mécanique quantique, les probabilités, l'algèbre et bien d'autres.

De plus, son utilisation par les transformations de Fourier permet de diminuer le coût
en temps des opérations par un ordinateur.

2 Utilisation dans le cas de notre méthode

Le produit de convolution peut-être utilisé dans le traitement et la manipulation

d'images, dans le but de déterminer le déplacement entre deux images. Une image de
référence est comparée à une image déformée.

On peut faire l'étude d'un cas simple d'un déplacement de courbe. Une fonction de
corrélation est introduite pour déterminer le déplacement entre un état de référence
représenté par la fonction f et un état déformé représenté par la fonction g.

Le point de f en x 0 est déplacé de u ; en g, il est donc en x 0 +u.

On peut donc écrire f( x 0 )=g( x 0 +u).

Ici, est introduite une norme représentant la distance déplacée de la courbe. Le

déplacement u est supposé petit.

G= ∫∫|f( x 0 ) - g( x 0 +u)|²dS ⇔ G= ∫∫(f( x 0 )² - 2f( x 0 )g( x 0 +u) + g( x 0 +u)²)dS

⇔ G = ∫∫f( x 0 )²dS - 2 ∫∫f( x 0 )g( x 0 +u)dS + ∫∫g( x 0 +u)²dS.

Nous cherchons à superposer les deux courbes obtenues. Afin d'avoir un écart entre
les courbes minimal, nous cherchons à minimiser l'intégrale ci-dessus qui représente la
surface de décalage entre les deux courbes.

11
C'est l'écart entre les deux courbes, lorsqu'elles sont placées comme sur la figure de droite:

g(x) f(x)
f(x) g(x)

Ainsi, G doit être minimal. Or, dans l'intégrale, la première intégrale ne dépend que
de la fonction f; de même, la troisième intégrale ne dépend que de la fonction g. Elles ne
changent donc pas. Ainsi, c'est la deuxième intégrale qui doit être minimale.

min G = min (- 2 ∫∫f( x 0 )g( x 0 +u)dS)

Minimiser cette expression revient à maximiser l'intégrale à cause du signe - .

⇒ max ∫∫f( x 0 )g( x 0 +u)dS .

On reconnaît le produit de convolution. Le fait de minimiser cette norme revient à maximiser

le produit de convolution.

En assimilant une image à une matrice de données de niveaux de gris, on peut

utiliser ce résultat pour calculer la corrélation entre 2 images.

En effet, le calcul utilisé par notre programme est le suivant:

On remarque très vite la similarité entre cette expression et l'expression de G définie

précédemment. Il est à noter qu'ici, I(X,Y) représente les coordonnées du point sur l'image
de base et T(x',y') représente les coordonnées de la boite que notre programme va corréler
avec l'image de base.

12
 3.2.2. Projections

Illustration 2: Schéma illustrant la projection

Voici les éléments mathématiques nous permettant de reconstituer la 3D, c'est à

dire de définir la profondeur en fonction du déplacement vertical et latéral d'un élément.

==> f (Xh, Xv) = (x0 – x)/sin(θ)

==> f (Xh, Xv) = (y – y0)/(sin(φ) * cos(θ))

Ces résultats mathématiques forment donc la base nécessaire aux calculs que nous
effectuerons pour reconstituer la 3D.
On remarque aussi que si θ et φ sont nuls, aucun calcul n'est possible.
On fera la moyenne de ces deux résultats pour calculer la profondeur que l'on
recherche.

13
4. EXPÉRIENCE ET RÉSULTATS

4.1. Dispositif expérimental

Illustration 3: Dispositif expérimental

Matériel:
− rétroprojecteur
− appareil photo avec trépied
− ordinateur
− objets à reconstituer
− mètre
Protocole:
− Se placer dans une salle sombre, par exemple avec des rideaux pour obtenir de
meilleures images
− Sélectionner un fond et le projeter sur mur blanc et plat en ajustant bien l'image
− Régler l'appareil photo, afin d'avoir une image nette et entière, en le plaçant le plus
haut possible avec un certain angle entre les axes de projection et de l'appareil photo
− Prendre les mesures nécessaires pour les calculs
− Prendre une photo du fond seul
− Placer l'objet devant le fond, en le centrant
− Reprendre une photo puis vérifier que la photo n'est pas floue et qu'il n'y a pas
d'ombre
− Refaire toutes les étapes pour chaque objet

14
Distances à mesurer:
− distance entre rétroprojecteur et mur
− différence de hauteur entre appareil photo et rétroprojecteur (qui correspond aussi à
la différence de hauteur entre appareil photo et centre du fond projeté)
− distance entre l'appareil photo et l'axe du rétroprojecteur

4.2. Logiciels utilisés

4.2.1. OpenCV

OpenCV est un logiciel qui regroupe un ensemble de librairies permettant le

traitement d'image.
Pourquoi nous l'avons choisi? Simplement car c'est un logiciel Open Source dont le
langage est très proche du C, et qui est donc très abordable pour des personnes de notre
niveau d'études.
La méthode que nous utilisons est très simple. Il suffit de rentrer deux images dans le
programme et il les traitera afin de vous ressortir un fichier texte dans lequel toutes les
positions d'origine et d'arrivée de chaque centre de bloc seront données, ainsi que le niveau
de corrélation.

En clair, le programme se contente de découper votre image de base en un certain

nombre de blocs de taille choisie, puis de faire correspondre ces blocs avec l'image objet
(c'est à dire l'image où l'objet est présent). En faisant cela, il notera tout de suite s'il y a eu ou
non un déplacement.

Prenons 2 exemples:

Supposons un bloc de taille 50*50 pixels positionné à l'emplacement 100*100 de votre

image de base (en partant d'en haut à gauche: 100 pixels vers le bas et 100 vers la droite).
Si sur l'image objet, aucune partie de l'objet n'est visible en 100*100, dans ce cas, le
programme détecte un bloc 50*50 identique sur l'image objet. Il ressortira donc une corrélation
maximum pour un déplacement nul.
D'autre part, si sur l'image objet, une partie de l'objet est visible en 100*100, le motif
(c'est à dire le bloc nous intéressant) sera légèrement décalé. Le programme ressortira donc une
corrélation maximum pour un déplacement (Δx,Δy) correspondant au décalage (en pixel) du bloc
par rapport à l'image de base.

On comprend donc rapidement que l'intérêt sera de créer une image avec des
motifs assez petits pour nous permettre de choisir des blocs de petite taille, augmentant
considérablement le nombre de points.
Cependant, la taille des blocs sera toujours limité à une taille minimale. Pour palier
à ce problème nous proposons donc une méthode de chevauchement.

15
 Reprenons notre exemple:

On considère notre bloc de 50*50 appartenant à une image de taille 1000*1000.

L'image peut ainsi être découpée en 20*20 blocs de 50*50 soit 400 blocs, et donc 400
vecteurs déplacement.
Avec un taux de chevauchement de 50%, chaque bloc sera composé à 50% du bloc
précédent. En clair, on aura 2 fois plus de bloc en largeur et 2 fois plus en hauteur, soit 4 fois
plus de blocs!! Ceci entraine donc que nous auront 1600 vecteurs déplacement!!!

Nous avons choisi de prendre des blocs de 10*10 dans des images de 1000*1000
pour notre étude avec un chevauchement de 50%.
L'image sera donc découpée en 100*100 blocs eux mêmes doublés sur la largeur et
la hauteur. Nous aurons donc un total de 40,000 vecteurs déplacement sur chacune de nos
images. La précision sera donc très importante.

Remarque: Le programme ainsi que son utilisation est clairement expliqué en Annexe.

4.2.2. Scilab

Scilab est un logiciel libre de calcul numérique multiplateforme, qui fournit un

environnement de calcul pour des applications scientifiques. En effet, il est utilisé dans
différents domaines tels que le traitement du signal, les simulations de dynamique des
fluides, l’optimisation numérique et dans notre cas, le traitement d’images.
Ce logiciel est semblable à Mathlab, au niveau du langage, de la syntaxe et des
différentes utilisations proposées.

Le programme OpenCV nous a précédemment permis de récupérer les données de

déplacement en X et Y de certaines zones de l'image. Scilab va se contenter de reprendre
ses données, pour définir la coordonnée Z (la profondeur) de l'objet, puis en donner une
représentation 3D assez simple.
Nous souhaitons, en effet, obtenir une représentation plus complète avec le logiciel
Blender, défini dans la partie suivante.
Nous n'avons cessé d'améliorer notre programme Scilab afin de perfectionner notre
représentation 3D. Par exemple, de nombreux filtres sont appliqués afin de ne prendre en
compte qu'un certain nombre de points correspondant à certains critères (corrélation
moyenne, hauteur maximum, etc...)
Le détail de ce programme et son explication se trouvent en annexe.

4.2.3. Blender

Dans le cadre de nos recherches, un moyen efficace pour convertir des données
issues des images 2D en images 3D a du être recherché. Après diverses pistes explorées,
celle qui nous est apparue la plus appropriée, que ce soit dans le maniement du logiciel ou
dans son application, a été celle du logiciel Blender.
Blender est un logiciel libre et gratuit d'animation, de modélisation et de rendu 3D.

16
C'est-à-dire que ses applications sont aussi diverses que variées. Dans le cadre de notre
projet, c'est la fonction de modélisation de Blender qui a été la plus employée. En effet, en
suivant ces étapes, nous pouvons modéliser une image 3D à partir d'un nuage de points.

Il faut tout d'abord savoir que Blender lit et exécute des programmes en langage
informatique python. Les travaux réalisés l'année dernière nous ont donnés l'algorithme
nécessaire pour la lecture d'un fichier en '.txt', qui comprend la matrice correspondant aux
coordonnées des points des images étudiés. La première difficulté rencontrée a été de
pouvoir comprendre l'algorithme car le python n'est pas un langage étudié à l'INSA.

Ensuite, l'utilisation du logiciel Blender a du être

abordée.

Après l'ouverture de Blender, il faut entrer les

différents algorithmes dans l'onglet 'Text Edit' tout en
n'oubliant pas de les enregistrer et de les compiler avant
d'essayer de les lancer.

L'algorithme ci-contre permet, à partir d'un fichier

« .txt » recensant les coordonnées de tous les points, de
créer la forme y correspondant.

On peut donc maintenant apercevoir, si l'on réduit

le zoom de l'écran dans l'onglet '3D view', l'apparition de
points regroupés sous une forme rectangulaire. Au vu du
manque de relief dans l'image obtenue, on pourrait penser que l'opération a échoué.
Cependant, il ne faut pas oublier de faire pivoter l'image, pour que les coordonnées suivant z
soient visibles. Apparaît alors une forme correspondant à celle cherchée.
On obtient finalement un nuage de point se présentant sous la forme attendue. Par
exemple sur la photographie ci-contre, on peut apercevoir une main :

Illustration 4: Résultat de la main sous Blender

17
 On va maintenant relier nos points et mettre nos facettes.

Comme nous l'avons dit précédemment, une première piste est de travailler sur
Blender avec les scripts du groupe de l'année dernière mais elle n'a pas aboutit car leurs
scripts ne fonctionnent bien que pour un ensemble de points « disposés dans un
agencement ordonné », ce qui est loin d'être le cas pour nous.
Cela dit, cette piste reste exploitable: on a pu trouver, sur jmsoler.free.fr, un script
(voir annexe) permettant de créer des facettes à partir d'un ensemble de points moins
ordonné. Le seul souci avec ce script réside dans le fait qu'il relie tous les points sans tenir
compte de la distance entre ces derniers, générant ainsi de très nombreuses surfaces
parasites s'étalant dans tous les sens (inutile de les supprimer à la main car c'est laborieux
et ça risque de déformer le nuage de points) . On aurait pu modifier ce script (en imposant
une taille maximale aux facettes par exemple), mais à défaut de maîtriser la programmation
Python, il nous était difficile de le faire.

Une autre piste, que l'on a finalement privilégiée, est de générer nos facettes avec
Meshlab, qui est un logiciel gratuit et facile à installer, permettant de travailler sur un maillage
3D. Il ne rivalisera pas avec Blender (car il a moins de fonctions que celui-ci) mais nous
permet déjà d'avoir un premier rendu. Alors, pour ce faire, voilà comment on procède:
1. Dans Blender, ouvrir le nuage de points et l'exporter sous un format objet:
File → Export → Wavefront(.obj).
2. Dans Meshlab, ouvrir le fichier .obj (notre nuage de points apparaît).
3. Pour créer les facettes, la fonction Ball Pivoting est celle qui marche le mieux
(facettes plus proches du modèle et peu de surfaces parasites):
Filters → Remeshing, simplification and reconstruction → Surface reconstruction: Ball
Pivoting.

Une fenêtre de dialogue (s'ouvrant automatiquement) permet d'adapter les paramètres de

remplissage en fonction de notre maillage. On obtient alors (après lissage):

18
 4. Tous les points sont a-priori reliés mais il y a des gros trous sur les bords: pour y
remédier on fait:
Filters → Remeshing, simplification and reconstruction → Surface reconstruction: Poisson.
Pour finalement obtenir:

Côté extérieur Côté intérieur

19
4.3. Compte-rendu de l’expérience

4.3.1. Compte-rendu de l’expérience réalisée

Le but de notre première expérience était de déterminer le type d'image à projeter

ainsi que sur quel type d'objet afin d'avoir une bonne représentation 3D. Nous avons suivi le
protocole expérimental afin de réaliser nos premiers essais. Cependant, pour cette
expérience « test » nous avons considéré que l’appareil photo était à la même hauteur que
le rétroprojecteur, l’angle entre le rétro et l’appareil pouvant suffire à réaliser un calcul de
profondeur.
Au niveau de l’expérience, nous avons réalisé plusieurs clichés de différents fonds
rétro-projetés avec différents objets ainsi qu’à différents angles. Nous avons utilisé
différentes images pour pouvoir comparer laquelle aurait le meilleur taux de corrélation. En
effet, pour avoir une bonne corrélation, il fallait éviter que l’image présente trop de régularités
tant dans les distances entre les points que dans les couleurs. Les différents objets utilisés
étaient un cylindre blanc, une main et une feuille de papier absorbant. Nous avons aussi
testé un visage mais nous nous sommes vite rendu compte que cela ne fonctionnerait pas,
l'absorption par le visage de la lumière projetée étant trop importante. Cette expérience nous
a permis d'éliminer l'idée de recréer un visage, c'est la raison pour laquelle nous nous
sommes fixé comme objectif la représentation 3D d'une main.
Le seul problème était que, à cet instant, nous ne savions toujours pas comment
récupérer les vecteurs déplacement à partir de nos deux images.

4.3.2. Récupération des données de l’expérience

Pour commencer, nous avons souhaité récupérer les vecteurs de déplacement de la

main sur un des trois fonds. Grâce à une collègue de M. Yon, nous avons pu obtenir toutes
les données qui nous étaient nécessaires, c’est-à-dire les coordonnées de points ayant subi
un déplacement et les coordonnées des vecteurs de déplacements de ces derniers.
Notre but était d’extraire ces données sous fichier texte pour pouvoir les utiliser dans
Blender. Mais pour pouvoir reconstruire l’objet en 3D, il nous a fallu déterminer la
coordonnée de profondeur des points (Z). Pour cela, nous avons utilisé le logiciel Scilab afin
de faire le calcul de la coordonnée Z que nous avons établi plus tôt.
Une fois les coordonnées récupérées, nous les avons traitées sous Blender et avons
eu notre première représentation 3D de la main. Cependant, nous avons remarqué qu’il y
avait des « trous » dans cette dernière, cela était dû au fond rétro-projeté. En effet, ce
dernier présentait des zones où il n’y avait aucun motif donc le logiciel de traitement d'image
n’avait pas pu faire la corrélation à cet endroit.
Ceci nous conforte donc dans l'idée d'un fond rétro-projeté qui ne doit pas être
homogène ou avec de trop gros motifs.
En parallèle, nous avons approfondi nos recherches sur Open CV. Ainsi, avec l’aide
de M.Yon nous avons pu mettre au point notre programme de corrélation d'images, nous
permettant d'acquérir tous les vecteurs déplacement.
20
 De plus, grâce à Scilab, nous avons réussi à filtrer nos résultats afin de supprimer un
maximum de points aberrants avant de les transmettre à Blender.
Grâce à ce logiciel, nous pouvons avoir une reproduction de l’objet grâce à un nuage
de points représentant la 3D.
Lors d'une seconde expérience, nous avons rétro-projeté un fond qui nous semblait
très approprié à ce type d'expérience. De plus, nous avons cette fois-ci utilisé l'appareil
photo à une hauteur différente de celle du rétro afin d'avoir un angle φ, nous permettant de
calculer une valeur moyenne de Z en fonction des deux résultats de Z obtenus. Les résultats
obtenus lors de cette seconde expérience sont très probants.

4.3.3. Résultats:

L'image de référence ainsi que l'image avec la main sont les suivantes:

Illustration 5: Image de Illustration 6: Image avec objet

référence (main)

Le résultat que nous avons obtenus sur Blender n'est pas à la hauteur de nos
espérances, puisque ce n'est qu'un nuage de points. Nous aurions aimé reconstruire une
réelle surface en 3D, mais ce n'est pas grave, comme vous avez déjà pu le voir, le résultat
est assez surprenant:

Comme vous pourrez le voir par la suite, une fonction de Scilab nous a permis de
recréer une surface 3D qui est malheureusement peu nette pour un grand nombre de points.
Cependant, elle nous sera utile à la compréhension de certains résultats.

21
 4.3.4. Analyse des résultats:

Pour être sûr que notre projet soit bien concret, il nous a fallu étudier quelques
aspects comme le respect des formes, la corrélation moyenne ou encore la taille des boites.
-Respect des formes:
Pour vérifier que les formes étaient bien respectées, nous avons projeté notre image
sur un plan, afin de savoir si le plan était bien représenté en 3D.
Voici le résultat que cela a donné:

On remarque évidemment le plan très bien représenté, malgré quelques points

aberrants. On peut donc dire très logiquement que notre méthode permet de conserver les
formes.
-Corrélation en fonction de la taille des boites:
Il est important de souligner que la taille des boîtes a une grande importance pour avoir une
bonne corrélation. Illustrons ceci avec une étude de comparaison entre les différentes tailles
de boîtes et le niveau de corrélation.

Illustration 7: Corrélation en fonction de la taille de boite

22
 On voit clairement que la corrélation moyenne est beaucoup plus importante si la
taille de la boite est minimum. Cependant, les effets de bords (points aberrants) sont plus
importants. Néanmoins il faut utiliser une boite de petite taille, sinon le relief n'est pas bien
représenté.
Pour pouvoir illustrer cette importance dans la taille des boîtes, nous avons réalisé un
programme Scilab (présent en annexe 7.4) qui réalise un maillage sur le nuage de points
permettant ainsi d’obtenir une surface de l’objet.

Illustration 8: Main avec boite 50*50

Illustration 9: Main avec boite 10*10 23

 Dans l’image 1, on peut voir qu’ici en prenant cette taille de boîte nous ne distinguons
pas réellement les doigts de la main on voit qu’il y a du relief cependant.
Dans l’image 2, on peut distinguer très nettement la main et ses doigts.
De plus, on peut dire que la profondeur est conservée car les mesures
expérimentales sont proportionnelles aux mesures réelles. En effet, la hauteur du poignet
réelle est de 3 cm pour 7 cm de large ce qui fait un rapport de 0.42 alors que pour les
mesures expérimentales on a 0.3. On peut donc conclure en disant que la profondeur est
globalement respectée mais l’écart des rapports n’est pas dû à la méthode utilisée mais
plutôt aux valeurs expérimentales telles que les angles et distances mesurées lors de
l’expérience.

-Taux de chevauchement:
Nous avons aussi étudié le taux de chevauchement, cependant il n'augmente pas la
corrélation moyenne. Malgré tout, il reste utile puisqu'il permet d'augmenter
considérablement le nombre de point pour lesquels les vecteurs déplacement seront
calculés. De cette façon, on peut réussir à « lisser » la représentation 3D.

24
5. CONCLUSIONS ET PERSPECTIVES

Pour conclure, on peut dire que la méthode de corrélation des images nous a permis
d’obtenir de bons résultats de reproduction 3D d’un objet à partir d’une image photographiée.
De plus, en utilisant OpenCV puis un programme Scilab, nous avons obtenu des données de
profondeur satisfaisantes et complètement automatisées, ce qui était un de nos plus
importants objectifs à remplir dans ce projet. Par ailleurs, bien que la méthode fonctionne
très bien, il reste des possibilités d’amélioration du rendu de la 3D. C’est pourquoi il nous
semble important de détailler les perspectives pour la poursuite de ce projet car cette
méthode semble être une bonne piste pour établir de bon résultats de reproduction de la 3D.

Ainsi, dans ce projet les perspectives de poursuites sont les suivantes. Par exemple,
il doit être possible d’améliorer les programmes informatiques afin de pouvoir obtenir de
bons résultats même avec des objets de plus grande taille que ceux utilisés dans notre
projet. En effet, les calculs demandés par le programme OpenCV sont tout de même assez
longs et le problème des ombres a été un frein également.
De plus, il est possible de trouver une méthode pour filtrer tous les points aberrants obtenus
dans la représentation 3D. En ce qui concerne Blender, il faudrait une plus grande maîtrise
du logiciel pour pouvoir avoir des représentations plus proches de la réalité et de l’objet en
question.

Par ailleurs, ce projet a pu nous apporter beaucoup de choses. En effet, il a été très
enrichissant du début jusqu’à la fin, il nous a permis de découvrir une méthode de
reconstruction 3D qui nous était jusqu'alors inconnue. En plus de nous permettre de travailler
en groupe (la répartition des tâches, la communication du groupe…), il nous a surtout permis
de découvrir de nouvelles choses, comme ici le traitement d'image, qui est un sujet
intéressant à étudier. Au départ, nous avons eu du mal à comprendre la méthode
néanmoins, nous sommes finalement parvenus à l’approfondir et ainsi améliorer le projet de
l’an dernier. Pour certains, cela a permis d’acquérir un certain nombre de méthodes de
recherche et d'analyse du problème ainsi que de se pencher sur des logiciels dont nous
n’avions pas l'habitude d'utiliser (tels que Scilab, Blender, GIMP, OpenCV..). Même malgré
quelques échecs, nous avons toujours essayé de les contourner et de trouver d'autres
moyens d'arriver à nos fins. Et cela apporte une certaine fierté personnelle lorsqu’on
s’aperçoit que le résultat est là et que cela semble plutôt bien fonctionner.

Malgré tout, nous avons atteint notre objectif principal qui était de rendre automatique
l'acquisition des données de déplacement.

25
6. BIBLIOGRAPHIE

Internet:

http://jmsoler.free.fr/didacticiel/blender/tutor/python_script01.htm
http://jmsoler.free.fr/didacticiel/blender/tutor/python_script02.htm
http://jmsoler.free.fr/didacticiel/blender/tutor/python_script03.htm
http://jmsoler.free.fr/didacticiel/blender/tutor/python_script04.htm
http://www.siteduzero.com/tutoriel-3-11714-debutez-dans-la-3d-avec-blender.html
http://perception.inrialpes.fr/Publications/2001/Stu01/jnrr_01.pdf
http://sourceforge.net/projects/meshlab/files/meshlab/MeshLab
%20v1.2.3/MeshLab_v123a.exe/download
http://meshlab.sourceforge.net/
http://code.google.com/p/project-meshlab-m1-anais-hafsa/downloads/detail?
name=Meshlab_rapport_hafsa_anais.doc
http://www.si.ens-cachan.fr/accueil_V2.php
http://fr.wikipedia.org/wiki/Scilab
http://fr.wikipedia.org/wiki/Produit_de_convolution

26
7. TABLE DES ILLUSTRATIONS

Illustration 1: Répartition des tâches pour les membres du groupe..........................................6

Illustration 2: Schéma illustrant la projection..........................................................................13
Illustration 3: Disposition expérimentale.................................................................................14
Illustration 4: Résultat de la main sous Blender......................................................................17
Illustration 5: Image de référence...........................................................................................21
Illustration 6: Image avec objet (main)....................................................................................21
Illustration 7: Corrélation en fonction de la taille de boîte.......................................................22
Illustration 8: Main avec boîte 50*50.......................................................................................23
Illustration 9: Main avec boîte 10*10.......................................................................................23
Illustration 10: Schéma de projection......................................................................................28

27
8. ANNEXES

8.1. Projections mathématiques

Illustration 10: Schéma de projection

Tout d'abord, notons que le projeté du point P dans la base de la surface est P'.
Dans cette base, il est donc de la forme:
O'P' = Xh * H + Xv * V + Xp * P

Or, nous recherchons en Xp en fonction de Xh et Xv.

On notera donc:
O'P' = Xh * H + Xv * V + f(Xh,Xv) * P (Équation n°1)

Nous nous occupons maintenant de l'appareil photo. Nous projetons les vecteurs de
la base dans le repère du projecteur.
cos(φ) * cos(θ) -sin(θ) sin(φ)*cos(θ)

Ainsi: C = -sin(φ) et Hc = 0 puis Vc = Hc ^ C = cos(φ)

(P, V, H) cos(φ)*sin(θ) (P, V, H) cos(θ) (P, V, H) sin(θ)*sin(φ)

28
Soit P'' le projeté de P' dans la base de l'appareil photo. On a:

O''P'' = O''O' + O'P' + P'P''

De plus: Xhc = O''P'' * Hc
Or O''P''*Hc = O'P' * Hc (car O''O' * Hc = P'P'' * Hc = 0)
D'où, d'après (1) :

Xhc = -sin(θ) * f (Xh, Xv) + Xh * cos(θ) (Équation n°2)

De même Xvc = O'P' * Hc

Et d'après (1) on retrouve:

Xvc = sin (φ) * cos (θ) * f (Xh, Xv) + cos (φ) * Xv + sin (θ) * sin (φ) * Xh (Équation n°3)

A ce stade, nous connaissons la position du point sur l'image par ses coordonnées
(Xhc,Xvc).
Par simple respect des conventions, nous poserons (Xhc,Xvc) = (x,y).

Dans l'image de base, c'est à dire sans objet, on peut donc définir la position de
base de tout point M défini par ses coordonnées (x0,y0). On peut toujours appliquer les
équations (2) et (3).
Ainsi:
x0 = -sin(θ) * f (Xh, Xv) + Xh * cos(θ)
y0 = sin(φ) * cos(θ) * f (Xh, Xv) + cos(φ) * Xv + sin(θ) * sin(φ) * Xh

Or, ici il n'y a pas d'objet, donc f (Xh, Xv) = 0.

Donc xh = x0/cos(θ) et xv = (y0 - sin(θ) * sin(φ) * Xh)/cos(φ)

xh = x0/cos(θ)
xv = y0/cos(φ) - tan(θ) * tan(φ) * x0

Il suffit maintenant de remplacer xh et xv par ces valeurs dans les équations (2) et
(3).
On trouve donc:
(2) ==> f (Xh, Xv) = (x0 – x)/sin(θ)
(3) ==> f (Xh, Xv) = (y – y0)/(sin(φ) * cos(θ))

29
8.2. Utilisation du programme Patern-Matching

Il est très simple d'utilisation, il suffit de suivre ces quelques étapes:

-Ouvrez le terminal de Windows: C:\Windows\System32\cmd.exe

-Placez vous dans le répertoire où se situent le programme compilé et les 2 images à

corréler.

-Puis tapez cette commande:

Patern_Matching.exe Image_Ref Image_Objet Largeur_Bloc Hauteur_Bloc taux_overlap

Remplacer Image_Ref et Image_Objet par le nom que vous leur avez donné. Ces images
doivent être au même format (bmp,jpg, etc...)
Remplacer Largeur et Hauteur_Bloc par la largeur et la hauteur du bloc désirées.
Le taux_overlap (chevauchement) doit être rentré en %, par exemple 50 pour 50%.

Par ex: Patern_Matching.exe ref1.jpg objet1.jpg 10 10 50

Le tour est joué, le fichier PaternMatching_Results.txt est généré et peut être utilisé.

30
8.3. Exemple de programme avec Scilab

1 :clf
2 :Angleteta=32.4*%pi/180;
3 :Anglephi=13*%pi/180
4 :correlationmin=0.9;
5 :distmax=200;

6 :A=fscanfMat('PaternMatching_Results.txt');
7 :xTab=A(:,1);yTab=A(:,2);deltaxTab=-A(:,3);deltayTab=-A(:,4);Correlation=A(:,5);
8 :zTab1=deltaxTab/sin(Angleteta);
9 :zTab2=deltayTab/(sin(Anglephi)*cos(Angleteta));
10 :zTab=-(zTab1);//+zTab2)/2;

11 :dist=sqrt(deltayTab.^2+deltaxTab.^2);
12 :Select=(Correlation>correlationmin & dist<distmax);
13 :param3d(xTab(Select),yTab(Select),zTab(Select))
14 :fprintfMat('PaternMatching_Results-filtre.txt',[xTab(Select),yTab(Select),zTab(Select)])

Explication du programme réalisé sous Scilab permettant d’obtenir la coordonnée de la

profondeur pour pouvoir faire la représentation 3D :

Ligne 2 : on définit l’angle theta en radian qui est l’angle entre le mur et l’appareil photo

Ligne 3 : on définit l’angle phi en radian qui est l’angle entre le rétro projecteur et l’appareil
photo

Ligne 4 : on détermine une corrélation minimum, de cette manière on souhaite ne prendre

qu’un taux supérieur ou égal à cette corrélation minimum pour avoir de meilleurs résultats en
ne prenant que les bonnes coordonnées des vecteurs déplacements corrélés

Ligne 5 : on détermine une distance max qui est la distance entre le point de départ et le
point corrélé.

Ligne 6 : cette commande indique la création d’un fichier texte PaternMatching où s’inscriront
les données mentionnées à la ligne 9

Ligne 7 : on veut que dans ce document apparait en première colonne les coordonnées x
obtenus avec l’autre programme en C++ avec utilisation d’Open CV, en deuxième colonne
les coordonnées y, en troisième colonne les coordonnées x des vecteurs qui ont été corrélés
grâce au programme également, en quatrième colonne les coordonnés y des vecteurs qui

31
ont été corrélés et dans la dernière colonne on souhaite obtenir le taux de la corrélation
obtenue en calculant ces derniers.

Ligne 8 : on exprime une des deux formules de z (obtenus grâce à des lois de projections)

Ligne 9 : on exprime la deuxième formule. En effet, on a tenu à mettre les deux formules car
de cette manière on utilise à la fois les deltaX et les deltaY, ce qui permet de lisser nos
résultats.

Ligne 10 : la colonne des résultats de z sera la moyenne des ztab1 et ztab2 obtenus avec
les formules précédentes.

Ligne 11 : cette commande indique que l’expression de la distance que l’on doit prendre
entre le point de départ et celui qui a été corrélé.

Ligne 12 : grâce à cette commande, on sélectionne que les corrélations supérieures à la

corrélation minimum que l’on a fixé au départ ainsi que la distance qui doit être inférieure à
celle de la distance maximum fixée également au départ. Cette condition permet d’éviter de
prendre des points beaucoup trop éloignés et ce qui fausserait nos résultats

Ligne 13 : une fois le programme exécuté afin de visualiser le résultat de la représentation

3D obtenue en fonction des XTab, YTab et ZTab qui répondent au critère de sélection définit
en ligne 12

Ligne 14 : on édite ces trois dernières dans le fichier PaternMatchingResults-filtre.

Ainsi une fois le programme exécuté, nous obtenons deux fichiers textes , l’un complet avec
toutes les données , l’autre avec les données filtrées celles qui nous permettent de meilleurs
résultats.

8.4. Programme sous Scilab permettant d’obtenir le maillage des points

clear;
clf
Angleteta=32.4*%pi/180;
Anglephi=13*%pi/180;
correlationmin=0.9;
TauRelatif=2;
distmax=80;

//lecture du fichier généré par le programme Patern_Matching.exe

A=fscanfMat('PaternMatching_Results-1.txt');
xTab=A(:,1);yTab=A(:,2);deltaxTab=A(:,3)-16;deltayTab=A(:,4)-4;Correlation=A(:,5);

32
//Calcul de la 3eme dimension
zTab1=deltaxTab/sin(Angleteta);
zTab2=deltayTab/(sin(Anglephi)*cos(Angleteta));
zTab=(zTab1+zTab2)/2+1;
lmax=max(max(xTab),max(yTab));

//Reconstitution des cartographies

i=1;j=0;nbpoints=1;
labelX(i)=xTab(nbpoints);
xTemp=xTab(1);
while nbpoints<=size(xTab,'*') then
if xTab(nbpoints)==xTemp then
j=j+1;
labelY(j)=yTab(nbpoints);
else
j=1;
i=i+1;
labelX(i)=xTab(nbpoints);
xTemp=xTab(nbpoints);
end
CartoZ(i,j)=zTab(nbpoints);
CartoCorr(i,j)=Correlation(nbpoints);
Cartodistance(i,j)=sqrt((deltaxTab(nbpoints))^2+(deltayTab(nbpoints))^2);
nbpoints=nbpoints+1;
end

//Filtre de la cartographie
for i=2:size(labelX,'*')-1
for j=2:size(labelY,'*')-1
Valmean=(CartoZ(i-1,j)+CartoZ(i-1,j-1)+CartoZ(i+1,j)+CartoZ(i+1,j+1)+CartoZ(i,j-
1)+CartoZ(i+1,j-1)+CartoZ(i,j+1)+CartoZ(i-1,j+1))/8;
if CartoCorr(i,j)<correlationmin | abs((CartoZ(i,j)-Valmean)/Valmean)>TauRelatif |
Cartodistance(i,j)>distmax | CartoZ(i,j)<0 | CartoZ(i,j)>70 then
CartoZ(i,j)=0;
end

33
 end
end

//Critère de sélection des résultats sur la base des distances et corrélations

dist=sqrt(deltayTab.^2+deltaxTab.^2);
Select=(Correlation>correlationmin & dist<distmax);

//Visu et génération d'un fichier de sortie

//param3d(xTab(Select),yTab(Select),zTab(Select))
clf
plot3d(labelX(2:$-1),labelY(2:$-1),CartoZ(2:$-1,2:$-1));
//f=gcf();
//f.color_map = graycolormap(250);
fprintfMat('PaternMatching_Results-filtre.txt',[xTab(Select),yTab(Select),zTab(Select)])

8.5. Script pour les facettes dans Blender:

import Blender
from Blender import NMesh

import math
from math import *

lobjet=Blender.Object.Get('Mesh')
me=lobjet.getData()

# Déclaration des compteurs

i=0
j=0

# nombre de points:
maxpoint= (à remplir)
n=sqrt(maxpoint)
34
for i in range(0,n,1):
# Ici commence le premier sous-programme
# quatre espaces d'indentation
for j in range(0,n,1):
# Ici commence la seconde boucle
# huit espaces d'indentation
v =NMesh.Vert(j,i,0)
me.verts.append(v)
# Fin de la boucle interne
#Fin de la boucle externe

#valeur entière de n
n0=int(n)

for i in range(0,n-1):
# Ici commence le premier sous-programme
# quatre espaces d'indentation
for j in range(0,n-1):
# Ici commence la seconde boucle
# huit espaces d'indentation
f=NMesh.Face()
f.v.append(me.verts[i*n0+j])
f.v.append(me.verts[i*n0+j+1])
f.v.append(me.verts[(i+1)*n0+j+1])
f.v.append(me.verts[(i+1)*n0+j])
# Après avoir complété a facette
# on l'ajoute à la liste de "me"
me.faces.append(f)
# Fin de la boucle interne
#Fin de la boucle externe

NMesh.PutRaw(me,"plane",1)
Blender.Redraw()

35