Voici la liste des mes réalisations rangées par ordre chronologique de la plus récente à plus la ancienne :




Création d'un environnement de vidéosurveillance






Site web : http://indapit.free.fr/m2sis-ciell/
Téléchargement : http://www.ciell.univ-mrs.fr/CIELL/SKYY/
Langage / Interface : Serveur (C++, OpenGL), Client (Java)
Domaines : Analyse d'image (Imagerie Numérique), réseau.

Il s'agit du projet industriel du master 2. Il permet de mettre en pratique les cours sur un sujet qu'il serait possible de rencontrer dans le monde industriel.

Suite à des vols et des dégradations dans les locaux du CIELL, le Centre Interdépartemental d'Enseignement des Langues de Luminy, l'équipe de travail nous a demandé de mettre en place un système de vidéosurveillance.

Vous trouverez sur la page de téléchargement le rapport que nous avons rendu, la présentation que nous avons faite mais aussi les manuels d'utilisateur et les deux protocôles que nous avons mis en place.






Segmentation d'un coeur humain




Téléchargement : ici (251,78 Ko)
Langage / Interface : C++, OpenGL, wxWidget
Domaine : Modélisation (Imagerie Numérique)

Le but de ce projet était de fournir des éléments de bases tels que l'érosion, la dilation et le seuillage pour permettre une segmentation d'un coeur humain.
L'application offre également la possibilité de visualiser l'organe en 3D (une fois la segmention faite). Ce dernier point n'est pas totalement terminé par manque de temps.

Deux vidéos de démonstration sont accessibles sur la page de téléchargement. La première montre l'utilisation du programme dans son ensemble alors que la seconde se concentre sur la reconstruction 3D. Cette dernière est une animation réalisée à partir d'une séquence de fichiers .obj obtenus grâce à ce programme.




Survol interactif d'un terrain 3D




Site web : http://indapit.free.fr/m2sis-vision/
Téléchargement : http://indapit.free.fr/m2sis-vision/index.php?page=telechargements
Langage / Interface : C++, OpenGL, GLUT
Domaines : Vision industrielle et télédétection.

Le programme permet de charger un fichier MNT (Modèle Numérique de Terrains) et d'y appliquer une texture.

Il offre également la possibilité d'afficher une animation (en définissant la trajectoire et la vitesse de la caméra).




Reconnaissance supervisée de chiffres manuscrits






Site web : http://indapit.free.fr/m1sis-ocr/
Téléchargement : aller sur le site
Langage / Interface : C, OpenGL, GLUT
Domaine : Analyse d'image (Imagerie Numérique)

Ce programme est issu du cours d'Analyse d'Image (Master 1ière année), trois personnes ont participé à son élaboration.

Le but était pour pouvoir faire la "reconnaissance supervisée de chiffres manuscrits" de façon automatique. Nous nous sommes donc appuyé sur l'algorithme des k plus proches voisins (vu en cours) pour trouver de quel type de chiffre l'image en question se rapprochait le plus.
Nous avons réalisé plusieurs tests pour en ajuster les réglages au mieux, et ainsi améliorer les résultats du programme.

Il nous a été demandé de rendre un rapport et de faire une soutenance orale pour présenter ce projet. Vous trouverez donc le rapport, la soutenance, les sources du code ainsi que les données utilisées sur le site (section "téléchargement").




Edition de polygônes




Téléchargement : ici (39,10 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Visualisaion scientifique (Imagerie Numérique)

Il s'agit d'un éditeur de polygônes avec la possibilité de faire une union et une intersection.
Le coloriage de l'intérieur de la forme est réalisé grâce à l'algorithme d'Atherton et Weiler.

Compilation : make (utilisation du makefile)
Utilisation : ./main (aucun paramètre nécéssaire)
Touches clavier
1 / 2 / 3 / 4 : mode d'affichage
DEL : supprime le point courant
c / C : création d'un nouveau polygône
r / R : colorie le polygône courant
a / A : ajoute un trou au polygône courant
p / P : affiche tous les points d'intersection
u / U : demande d'union entre deux polygône
i / I : demande d'intersection entre deux polygône
e / E : efface tout
ESCAPE : quitte le programme

Algorithme du Z-Buffer


Téléchargement : ici (17,84 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Modélisation (Imagerie Numérique)

Programme qui implémente l'algorithme du Z-Buffer. On place un objet (ici un cube) et on ne souhaite afficher que les parties visibles, c'est à dire celles qui ne se trouvent pas derrières une face.
La partie de gauche est la partie programmée, celle de droite est l'affichage fait par OpenGL.

Compilation : make (utilisation du makefile)
Utilisation : ./main config (paramètre obligatoire : fichier de configuration)
Touches clavier
+ / - : changement de la focale
ESPACE : rendu en rotation
a / z : changement de la vitesse de rotation
f / F : mode fil de fer
t / T : application de l'algorithme du Z-Buffer
ESCAPE : quitte le programme

Algorithme de Bresenham
Téléchargement : ici (11,01 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Modélisation (Imagerie Numérique)

Calcule le tracé d'une droite grâce à l'algorithme de Bresenham.

Compilation : make (utilisation du makefile)
Utilisation : ./main (aucun paramètre nécéssaire)
Touches clavier
b / B : affichage du tracé par la méthode de Bresenham
n / N : affichage du tracé "simple"
+ / - : changement du pas
e / E : efface tout
ESCAPE : quitte le programme

Surfaces implicites






Téléchargement : ici (73,87 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Modélisation (Imagerie Numérique)

Les surfaces implicites sont des formes géométrique qui n'existent pas (au sens sommet, arète), elles sont modélisées à partir de leur graine (leur point central) et leur zone d'influence. Chaque graine donnera une sphère (plus ou moins grosse suivant l'influence qu'elle aura).
En se situant dans un gros cube et en divisant cet espace, il est alors possible de savoir à quel endroit chaque graine influe. Si plusieurs graines jouent un rôle dans un sous-cube, la couleur finale de ce dernier sera donc en fonction de leur couleur respective (et de leur influence bien sûr).
On peut donc mailler chaque "boule" (graine entourée de sa zone d'influence) pour obtenir des surfaces implicites.

Compilation : make (utilisation du makefile)
Utilisation : ./main (aucun paramètre nécéssaire)
Touches clavier
q / Q : affichage du quadrillage
s / S : sauvegarde du maillage réalisé (au format OBJ)
k / m : déplacement de la graine 1 (axe x)
o / l : déplacement de la graine 1 (axe y)
p / i : déplacement de la graine 1 (axe z)
a / Z : zoom
w / x : changement de l'influence de la graine 1
f / F : mode fil de fer
y / Y : affichage sur la console des informations du maillage
+ / - : changement du degré (qualité)
ESCAPE : quitte le programme

Surface




Téléchargement : ici (56,35 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Modélisation (Imagerie Numérique)

Modélisation d'une surface de Bézier et BSpline. Il s'agit de la même méthode que pour les courbes du même nom (ici), mais appliquée à la 3d.

Compilation : make (utilisation du makefile)
Utilisation : ./main liste_points (paramètre obligatoire : fichier contenant la liste des points à charger)
Touches clavier
b / B : surface BSpline
n / N : surface Bézier
f / F : mode plein écran
ESPACE : rendu en rotation
- / + : changement de la vitesse de rotation
a / z : changement du pas
q / s : zoom sur les points
8 / 2 : zoom sur le rendu
ESCAPE : quitte le programme

Enveloppe convexe 2d
Téléchargement : ici (54,43 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Modélisation (Imagerie Numérique)

Cette application affiche l'enveloppe convexe 2d qui entoure tous points cliqués.

Compilation : make (utilisation du makefile)
Utilisation : ./main (aucun paramètre nécéssaire)

Affichage d'un maillage et déplacement de points






Téléchargement : ici (971,57 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Modélisation (Imagerie Numérique)

Programme basé sur GLM (permet de charger un fichier OBJ). Ajout des arètes dans la structure de données permettant de faire bouger n'importe quel point / arète / triangle de la scène.

Compilation : make (utilisation du makefile)
Utilisation : ./maillage fichier_OBJ (paramètre obligatoire : fichier OBJ)
Touches clavier
z / Z : mode d'affichage (point, arète, triangle)
m / M : déplacement x (+1)
k / K : déplacement x (-1)
o / O : déplacement y (+1)
l / L : déplacement y (-1)
i / I : déplacement z (+1)
p / P : déplacement z (-1)
o / O : déplacement y (+1)
8 / 2 : zoom
+ / - : changement d'objet (suivant/précédent)
d / D : mode fil de fer / rempli
s / S (smooth) : active/desactive le smooth
f / F : active/desactive les materiaux (fichiers mtl)
b / B (bord) : affiche les points du bord du modèle en bleu
a / A (arète) : affiche les arètes liées à l'objet courant
t / T (triangle) : affiche les triangles liés à l'objet courant
e / E : affiche le plan qui passe par le triangle courant
ESCAPE (quit) : quitte le programme

Interpolation - Approximation




Téléchargement : ici (35,87 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Modélisation (Imagerie Numérique)

Trois petits programmes qui affichent une courbe qui interpolent ou approximent des points de contrôles (Hermit, Bézier, BSpline).

Compilation : make (utilisation du makefile)
Utilisation : ./main (aucun paramètre nécéssaire)
Touches clavier
c / C : affichage de la courbe
+ / - : changement du pas
e / E : effacer tous les points
ESCAPE (quit) : quitte le programme

Beizer uniquement :
a / z : déplacement du point pour la construction de DeCasteljau
BSpline uniquement :

a / z : changement du degré
Hermit uniquement :

c / v : changement de l'importance des tangentes

http://benjamin.duplex.free.fr/
Téléchargement : ici (237,18 Ko)
Langage / Interface : PHP, xHTML, CSS
Domaine : Site web

Site regroupant l'ensemble de mes réalisations, que ce soit dans le cadre de mes études ou personnel.











Application des k plus proches voisins




Téléchargement : ici (219,52 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Analyse d'image et reconnaissance de formes (Imagerie Numérique)

Ce programme permet de segmenter (classifier) une image en n couleurs (n étant choisi par l'utilisateur).

Il charge une image et affiche la répartition de ses couleurs dans trois plans de projections du cube RGB (Rouge/Vert, RougeBleu, Bleu/Vert). Après avoir choisi le nombre de classes, l'application affiche l'image source segmentée.

Compilation : make (utilisation du makefile)
Utilisation : ./main image (paramètre obligatoire : fichier image à segmenter)

Analyse en Composantes Principales




Téléchargement : ici (10,03 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Analyse d'image et reconnaissance de formes (Imagerie Numérique)

L'analyse en composantes principales (ACP) est une méthode mathématique d'analyse des données qui consiste à rechercher les directions de l'espace qui représentent le mieux les corrélations entre n variables aléatoires (ici n points).

L'ACP est aussi connue sous le nom de transformée de Karhunen-Loève ou de transformée de Hotelling (en l'honneur d'Harold Hotelling).

Les n points sont encadrés d'une boite englobante rectangulaire bleu se trouvant le nouveau repère (axes violet et vert).

Compilation : make (utilisation du makefile)
Utilisation : ./main [liste_points] (paramètre optionnel : fichier contenant une liste de points)
Touches clavier
s / S (sauvegarde) : sauvegarde les points dans le fichier pts.txt
q / Q / ESCAPE (quit) : quitte le programme

Transformée de Hough








Téléchargement : ici (12,57 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Analyse d'image (Imagerie Numérique)

Il s'agit simplement du codage de l'algorithme de la transformée de Hough (appliquée aux droites).
Ce programme permet donc de trouver les droites dans une série de points. Ces derniers sont mémorisés en cliquant dans la fenètre de gauche (le drag est implémenté pour que l'ajout soit plus rapide).

Compilation : make (utilisation du makefile)
Utilisation : ./main (aucun paramètre nécéssaire)
Touches clavier
d / D (delete) : supprime tous les points mémorisés
z / Z (zone) : affiche la zone d'influence de chaque droite
h / H (Hough) : applique la transformation de Hough
q / Q / ESCAPE (quit) : quitte le programme
Equation paramétrique d'une droite
ro = x.cos(teta) + y.cos(teta)

Double cône HLS to RGB




Téléchargement : ici (8,72 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Analyse d'image (Imagerie Numérique)

Programme qui permet de visualiser la représentation du modèle HLS. L'axe vertical correspond à la luminance L (lightness), l'axe horizontal à la saturation S (saturation) et le tour du cône à la teinte H (hue).

Compilation : make (utilisation du makefile)
Utilisation : ./main (aucun paramètre nécéssaire)
Touches clavier
a / A : on augmente la luminance (on monte dans le cône)
z / Z : on baisee la luminance (on descend dans le cône)
+ / - : changement du pas utilisé pour H
* / / : changement du pas utilisé pour S
q / Q / ESCAPE : quitte le programme

Site du projet WaLs ::: FTP
Téléchargement : ici (1,64 Mo)
Langage / Interface : PHP, xHTML, CSS, MySQL
Domaine : Site web

Il s'agit du site dédié au programme WaLs ::: FTP. Il sert à exposer le projet plus en détails et possède un bug-tracker pour essayer de corriger le plus d'erreurs possible.
Il est disponible à cette addresse : http://tripoprog.free.fr/WaLsFTP/

Traitements d'images




Téléchargement : ici (572,70 Ko)
Langage / Interface : C, OpenGL, GLUT
Domaine : Analyse d'image et morphologie mathématique (Imagerie Numérique)

Ce programme permet de faire quelques traitements sur des images binaires ou des images en niveau de gris.
Il peut donc afficher l'histogramme, effectuer des opérations d'amélioration (comme l'expansion dynamique, l'égalisation d'histogramme), utiliser un filtre, rechercher les contours ou encore appliquer des opérations de reconnaissance de formes (comme une érosion une dilatation, une squelettisation...).

Compilation : make (utilisation du makefile)
Utilisation : ./morpho image_a_traiter (paramètre obligatoire : fichier image à traiter)

WaLs ::: FTP
Site web : http://tripoprog.free.fr/WaLsFTP/
Téléchargement : aller sur le site
Langage / Interface : C, C++
Domaine : Réseau

Cette application, qui n'est pour l'heure qu'en version alpha (mais opérationnel), est un projet personnel qui avance doucement.
Il s'agit d'un serveur FTP dont le but premier est de fonctionner aussi bien sous Windows que sous Linux (WaLs signifiant "Windows and Linux server").
Il est dépourvu d'interface graphique car se pilote par des commandes UDP via Telnet. Un programme de monitoring (avec une interface) devrait voir le jour lorsque le serveur sera un peu plus abouti.
Validate XHTML 1.0 Strict
2007-2012 Tripo (email)