Wiki d'activités IMA - Contributions de l’utilisateur [fr]

P6 Gestion des flux thermiques du bâtiment Polytech

2014-10-09T08:43:05Z

Zassaieb : /* Cahier des charges */

== Présentation du projet ==
===Contexte===
Ce projet s'inscrit dans la continuité d'un projet entamé en IMA4 et qui consiste en la réalisation d'un système intelligent de régulation des flux thermiques des radiateurs installés à Polytech Lille pour essayer de réduire au maximum les pertes d'énergie engendrées. Il est réalisé dans le cadre du projet de développement durable initié par la direction de l'école.
===Objectif===
Réaliser un système intelligent capable de réguler le flux thermique d'un radiateur d'une salle à Polytech Lille, afin de maintenir la température de cette dernière à valeur constante, en prenant compte certains paramètres parmi lesquels: planning des salles, données météo ou température extérieure … , ainsi que les situations: fenêtre ouverte, utilisation imprévue de salle ... .

Le résultat final est un démonstrateur sur la plateforme de test constitué du radiateur équipé de l'électrovanne automatisé. Par ailleurs, une interface de supervision doit être établi, une interface homme-machine à destination des utilisateurs de la salle peut aussi être envisageable.
===Cahier des charges===
*Choix logistique et installation de l'équipement: électrovanne, capteurs, API

*Régulation et commande du radiateur : modélisation, simulation, mises en places des algorithmes et implémentation dans l'API

*Supervision : Simulation du système de défaillance et réalisation de l'interface

*Établir la connexion aux données du planning des salles et données météo

*IHM : Réaliser une interface conviviale avec authentification et gestion des modes de chauffage

==Déroulement du projet==
===Semaine 1 : 15/09 - 21/09===
* Analyse du projet

* Réalisation du cahiers des charges et définition des taches

* Etudes comparative des différents équipements

* Comparaisons des entreprises collaboratrices

* Etudes des solutions envisagées

===Semaine 2 : 22/09 - 28/09===
* Réalisation du diagramme Gant du projet

* Commande des composants chez wago

* Communication avec le directeur technique de Polytech pour diverses informations techniques vis-à-vis des radiateurs

* Analyse du système de commande existant ( projet IMA4 )

===Semaine 3 : 29/09 - 05/10===
* Modélisation du système

* Contact avec WAGO pour le suivi de la commande des pièces

P6 Gestion des flux thermiques du bâtiment Polytech

2014-10-09T08:40:06Z

Zassaieb : /* Semaine 2 : 22/09 - 28/09 */

== Présentation du projet ==
===Contexte===
Ce projet s'inscrit dans la continuité d'un projet entamé en IMA4 et qui consiste en la réalisation d'un système intelligent de régulation des flux thermiques des radiateurs installés à Polytech Lille pour essayer de réduire au maximum les pertes d'énergie engendrées. Il est réalisé dans le cadre du projet de développement durable initié par la direction de l'école.
===Objectif===
Réaliser un système intelligent capable de réguler le flux thermique d'un radiateur d'une salle à Polytech Lille, afin de maintenir la température de cette dernière à valeur constante, en prenant compte certains paramètres parmi lesquels: planning des salles, données météo ou température extérieure … , ainsi que les situations: fenêtre ouverte, utilisation imprévue de salle ... .

Le résultat final est un démonstrateur sur la plateforme de test constitué du radiateur équipé de l'électrovanne automatisé. Par ailleurs, une interface de supervision doit être établi, une interface homme-machine à destination des utilisateurs de la salle peut aussi être envisageable.
===Cahier des charges===
*Choix logistique et installation de l'équipement: électrovanne, capteurs, API

*Régulation et commande du radiateur : modélisation, simulation, mises en places des algorithmes et implémentation dans l'API

*Supervision : Simulation du système de défaillance et réalisation de l'interface

*IHM : Réaliser une interface conviviale avec authentification et gestion des modes de chauffage

==Déroulement du projet==
===Semaine 1 : 15/09 - 21/09===
* Analyse du projet

* Réalisation du cahiers des charges et définition des taches

* Etudes comparative des différents équipements

* Comparaisons des entreprises collaboratrices

* Etudes des solutions envisagées

===Semaine 2 : 22/09 - 28/09===
* Réalisation du diagramme Gant du projet

* Commande des composants chez wago

* Communication avec le directeur technique de Polytech pour diverses informations techniques vis-à-vis des radiateurs

* Analyse du système de commande existant ( projet IMA4 )

===Semaine 3 : 29/09 - 05/10===
* Modélisation du système

* Contact avec WAGO pour le suivi de la commande des pièces

P6 Gestion des flux thermiques du bâtiment Polytech

2014-10-09T08:38:17Z

Zassaieb : /* Déroulement du projet */

== Présentation du projet ==
===Contexte===
Ce projet s'inscrit dans la continuité d'un projet entamé en IMA4 et qui consiste en la réalisation d'un système intelligent de régulation des flux thermiques des radiateurs installés à Polytech Lille pour essayer de réduire au maximum les pertes d'énergie engendrées. Il est réalisé dans le cadre du projet de développement durable initié par la direction de l'école.
===Objectif===
Réaliser un système intelligent capable de réguler le flux thermique d'un radiateur d'une salle à Polytech Lille, afin de maintenir la température de cette dernière à valeur constante, en prenant compte certains paramètres parmi lesquels: planning des salles, données météo ou température extérieure … , ainsi que les situations: fenêtre ouverte, utilisation imprévue de salle ... .

Le résultat final est un démonstrateur sur la plateforme de test constitué du radiateur équipé de l'électrovanne automatisé. Par ailleurs, une interface de supervision doit être établi, une interface homme-machine à destination des utilisateurs de la salle peut aussi être envisageable.
===Cahier des charges===
*Choix logistique et installation de l'équipement: électrovanne, capteurs, API

*Régulation et commande du radiateur : modélisation, simulation, mises en places des algorithmes et implémentation dans l'API

*Supervision : Simulation du système de défaillance et réalisation de l'interface

*IHM : Réaliser une interface conviviale avec authentification et gestion des modes de chauffage

==Déroulement du projet==
===Semaine 1 : 15/09 - 21/09===
* Analyse du projet

* Réalisation du cahiers des charges et définition des taches

* Etudes comparative des différents équipements

* Comparaisons des entreprises collaboratrices

* Etudes des solutions envisagées

===Semaine 2 : 22/09 - 28/09===
* Réalisation du diagramme Gant du projet ( Annexe )

* Commande des composants chez wago

* Communication avec le directeur technique de Polytech pour diverses informations techniques vis-à-vis des radiateurs

* Analyse du système de commande existant ( projet IMA4 )

===Semaine 3 : 29/09 - 05/10===
* Modélisation du système

* Contact avec WAGO pour le suivi de la commande des pièces

P6 Gestion des flux thermiques du bâtiment Polytech

2014-10-09T08:32:42Z

Zassaieb : /* Cahier des charges */

== Présentation du projet ==
===Contexte===
Ce projet s'inscrit dans la continuité d'un projet entamé en IMA4 et qui consiste en la réalisation d'un système intelligent de régulation des flux thermiques des radiateurs installés à Polytech Lille pour essayer de réduire au maximum les pertes d'énergie engendrées. Il est réalisé dans le cadre du projet de développement durable initié par la direction de l'école.
===Objectif===
Réaliser un système intelligent capable de réguler le flux thermique d'un radiateur d'une salle à Polytech Lille, afin de maintenir la température de cette dernière à valeur constante, en prenant compte certains paramètres parmi lesquels: planning des salles, données météo ou température extérieure … , ainsi que les situations: fenêtre ouverte, utilisation imprévue de salle ... .

Le résultat final est un démonstrateur sur la plateforme de test constitué du radiateur équipé de l'électrovanne automatisé. Par ailleurs, une interface de supervision doit être établi, une interface homme-machine à destination des utilisateurs de la salle peut aussi être envisageable.
===Cahier des charges===
*Choix logistique et installation de l'équipement: électrovanne, capteurs, API

*Régulation et commande du radiateur : modélisation, simulation, mises en places des algorithmes et implémentation dans l'API

*Supervision : Simulation du système de défaillance et réalisation de l'interface

*IHM : Réaliser une interface conviviale avec authentification et gestion des modes de chauffage

==Déroulement du projet==
===Semaine 1 : 15/09 - 21/09===

===Semaine 2 : 22/09 - 28/09===

===Semaine 3 : 29/09 - 05/10===

P6 Gestion des flux thermiques du bâtiment Polytech

2014-10-09T08:31:45Z

Zassaieb :

== Présentation du projet ==
===Contexte===
Ce projet s'inscrit dans la continuité d'un projet entamé en IMA4 et qui consiste en la réalisation d'un système intelligent de régulation des flux thermiques des radiateurs installés à Polytech Lille pour essayer de réduire au maximum les pertes d'énergie engendrées. Il est réalisé dans le cadre du projet de développement durable initié par la direction de l'école.
===Objectif===
Réaliser un système intelligent capable de réguler le flux thermique d'un radiateur d'une salle à Polytech Lille, afin de maintenir la température de cette dernière à valeur constante, en prenant compte certains paramètres parmi lesquels: planning des salles, données météo ou température extérieure … , ainsi que les situations: fenêtre ouverte, utilisation imprévue de salle ... .

Le résultat final est un démonstrateur sur la plateforme de test constitué du radiateur équipé de l'électrovanne automatisé. Par ailleurs, une interface de supervision doit être établi, une interface homme-machine à destination des utilisateurs de la salle peut aussi être envisageable.
===Cahier des charges===
Choix logistique et installation de l'équipement: électrovanne, capteurs, API

Régulation et commande du radiateur : modélisation, simulation, mises en places des algorithmes et implémentation dans l'API

Supervision : Simulation du système de défaillance et réalisation de l'interface

IHM : Réaliser une interface conviviale avec authentification et gestion des modes de chauffage

==Déroulement du projet==
===Semaine 1 : 15/09 - 21/09===

===Semaine 2 : 22/09 - 28/09===

===Semaine 3 : 29/09 - 05/10===

P6 Gestion des flux thermiques du bâtiment Polytech

2014-10-01T08:38:41Z

Zassaieb : Page créée avec « == Présentation du projet == ===Contexte=== ===Objectif=== ===Cahier des charges=== ==Déroulement du projet== ===Semaine 1 : 15/09 - 21/09=== ===Semaine 2 : 22/09 - 28/... »

== Présentation du projet ==
===Contexte===
===Objectif===
===Cahier des charges===

==Déroulement du projet==
===Semaine 1 : 15/09 - 21/09===

===Semaine 2 : 22/09 - 28/09===

===Semaine 3 : 29/09 - 05/10===

Projets IMA5 2014/2015

2014-10-01T08:27:01Z

Zassaieb : /* Répartition des binômes */

Merci de référencer vos pages de projets ici. Merci aussi d'uniformiser vos formats que ce soit en regardant la présentation des projets déjà créés ou en allant modifier le format des précédents si votre façon de faire vous semble la meilleure. Dans tous les cas un minimum de communication entre les binômes est conseillée.

== Répartition des binômes ==

<table border="1">
<th>Projet</th>
<th>Elèves</th>
<th>Encadrant Ecole</th>
<th>Rapport décembre</th>
<tr>
<td>[[P6 Gestion des flux thermiques du bâtiment Polytech]]</td>
<td>Florian Royer / Zohour Assaieb </td>
<td> Belkacem Ould Bouamama </td>
<td> </td>
</tr>
<tr><td>[[P8 Pilulier]]</td>
<td> Alexandre Mercier / Emile Pinet</td>
<td> Thomas VANTROYS / Alexandre BOE </td>
<td></td>
</tr>
<tr><td>[[P9 Agenda pour personnes non lectrices]]</td>
<td> Cédric DESPREZ & Soufiane HADDAOUI </td>
<td> GAPAS/Laurent Grisoni </td>
<td></td>
</tr>
<tr><td>[[P11 Détecteur d'obstacles pour fauteuils électriques]]</td>
<td> Geoffrey ROSE / Marjorie TIXIER </td>
<td> GAPAS / Blaise Conrard </td>
<td></td>
</tr>
<tr><td>[[P21 balise Bluetooth Low Energy]]</td>
<td> Kévin CHALONO / Armagan YAMNAZ</td>
<td> Thomas VANTROYS </td>
<td></td>
</tr>
<tr><td>[[P22 Google Glass en logistique ]]</td>
<td> Jérémy Gondry / Vincent Meunier </td>
<td> Laurent Grisoni </td>
<td></td>
</tr>
<tr><td>[[P24 Robot de surveillance domestique]]</td>
<td> Sébastien DELTOMBE </td>
<td> Xavier Redon </td>
<td></td>
</tr>
<tr><td>[[P28 Modélisation d'un robot chirurgical déformable pour la simulation et le contrôle]]</td>
<td> Charlotte BRICOUT / Nathan MARTIN </td>
<td> Jérémie DEQUIDT</td>
<td></td>
</tr>
<tr><td>[[P33 Ligthing contactless / « wireless]]</td>
<td> Benjamin Lafit </td>
<td> -- </td>
<td></td>
</tr>
<tr><td>[[P44 Création d'un systeme domotique sans fil ]]</td>
<td> Benoit MALIAR / Thomas MAURICE</td>
<td> Pierrick BURET / Thomas VANTROYS </td>
<td></td>
</tr>
<tr><td>[[P45 Aide à la navigation d'un véhicule autonome]]</td>
<td> Pierre APPERCÉ</td>
<td> Rochdi MERZOUKI </td>
<td></td>
</tr>
<tr><td>[[P46 Simulation Temps Réel d'un Environnement de Robots Autonomes Logisticiens]]</td>
<td> Valentin VERGEZ</td>
<td> Rochdi MERZOUKI </td>
<td></td>
</tr>
<tr><td>[[P59 Assistance globale pour aide au parking]]</td>
<td> Mathieu GERIER / Céline LY </td>
<td> Alexandre BOE / Thomas VANTROYS </td>
<td></td>
</tr>
</table>

Fichier:RapportProjetIMA4 OutOfSpace.pdf

2014-04-15T22:16:37Z

Zassaieb :

Out of Space

2014-04-15T22:15:59Z

Zassaieb :

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT est une interface de programmation orientée objet et développée en C++. Elle offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc. Par certains aspects c’est aussi un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des “signaux” et “slots” par exemple.

== Déroulement du projet ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Travail réalisé==
===Sur Unity===

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>

[[Fichier:Unity1.png|vignette|alt=texte alternatif|Scène Unity]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on aie un ‘ground’ (qui correspond à l’écran stéréoscopique) et qui soit parallèle à la scène et aillant les mêmes dimensions que cette dernière, afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>

[[Fichier:Unity2.png|vignette|alt=texte alternatif|Scène résultat]]

===Sur QT===
;Outil de calibration : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non :information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique :sans avoir à modifier les lignes de code de l’application.

;Calibrage : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation :de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit :de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà :développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner :dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application :enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis :dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé :par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler :l’affichage.

----

Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT. <br\>
Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\>

*Première fenêtre :
La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien s’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
<center>[[Fichier:Mainwindow.PNG]]</center> <br\>
Dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>

MainWindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui
{
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H

MainWindow.cpp :

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent),

ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}

<br\><br\>

----
* Deuxième fenêtre :
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

<center>[[Fichier:Setupcalibration.PNG]]</center><br\>

La fenêtre qui permet la calibration est la suivante :<br\>
<center>[[Fichier:Kinect.PNG]]</center><br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>

----

* Troisième fenêtre:
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
<center>[[Fichier:Fin.PNG]]</center><br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>

Fincalibration.h

#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>

Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

== Rapport ==

[[Média:RapportProjetIMA4_OutOfSpace.pdf]]

Out of Space

2014-04-15T20:07:19Z

Zassaieb : /* Semaine 31/03 – 04/04 */

Out of Space

2014-04-15T20:07:00Z

Zassaieb : /* Sur QT */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT est une interface de programmation orientée objet et développée en C++. Elle offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc. Par certains aspects c’est aussi un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des “signaux” et “slots” par exemple.

== Déroulement du projet ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Travail réalisé==
===Sur Unity===

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>

[[Fichier:Unity1.png|vignette|alt=texte alternatif|Scène Unity]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on aie un ‘ground’ (qui correspond à l’écran stéréoscopique) et qui soit parallèle à la scène et aillant les mêmes dimensions que cette dernière, afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>

[[Fichier:Unity2.png|vignette|alt=texte alternatif|Scène résultat]]

===Sur QT===
;Outil de calibration : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non :information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique :sans avoir à modifier les lignes de code de l’application.

;Calibrage : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation :de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit :de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà :développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner :dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application :enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis :dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé :par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler :l’affichage.

----

Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT. <br\>
Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\>

*Première fenêtre :
La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien s’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
<center>[[Fichier:Mainwindow.PNG]]</center> <br\>
Dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>

MainWindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui
{
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H

MainWindow.cpp :

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent),

ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}

<br\><br\>

----
* Deuxième fenêtre :
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

<center>[[Fichier:Setupcalibration.PNG]]</center><br\>

La fenêtre qui permet la calibration est la suivante :<br\>
<center>[[Fichier:Kinect.PNG]]</center><br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>

----

* Troisième fenêtre:
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
<center>[[Fichier:Fin.PNG]]</center><br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>

Fincalibration.h

#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>

Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:58:49Z

Zassaieb : /* Sur Unity */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT est une interface de programmation orientée objet et développée en C++. Elle offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc. Par certains aspects c’est aussi un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des “signaux” et “slots” par exemple.

== Déroulement du projet ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Travail réalisé==
===Sur Unity===

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>

[[Fichier:Unity1.png|vignette|alt=texte alternatif|Scène Unity]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on aie un ‘ground’ (qui correspond à l’écran stéréoscopique) et qui soit parallèle à la scène et aillant les mêmes dimensions que cette dernière, afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>

[[Fichier:Unity2.png|vignette|alt=texte alternatif|Scène résultat]]

===Sur QT===
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT. <br\>
Nous avons développé une interface graphique qui permet à un non informaticien de calibrer les Kinects de l’installation. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\><br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\>

----
*Première fenêtre :
La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien s’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
<center>[[Fichier:Mainwindow.PNG]]</center> <br\>
Dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>

MainWindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui
{
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H

MainWindow.cpp :

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent),

ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}

<br\><br\>

----
* Deuxième fenêtre :
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

<center>[[Fichier:Setupcalibration.PNG]]</center><br\>

La fenêtre qui permet la calibration est la suivante :<br\>
<center>[[Fichier:Kinect.PNG]]</center><br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>

----

* Troisième fenêtre:
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
<center>[[Fichier:Fin.PNG]]</center><br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>

Fincalibration.h

#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>

Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:58:29Z

Zassaieb : /* Sur QT */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT est une interface de programmation orientée objet et développée en C++. Elle offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc. Par certains aspects c’est aussi un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des “signaux” et “slots” par exemple.

== Déroulement du projet ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Travail réalisé==
===Sur Unity===

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>

[[Fichier:Unity1.png|vignette|alt=texte alternatif|Scène Unity]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on aie un ‘ground’ (qui correspond à l’écran stéréoscopique) et qui soit parallèle à la scène et aillant les mêmes dimensions que cette dernière, afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>

[[Fichier:Unity2.png|vignette|alt=texte alternatif|Scène résultat]]

----

----

===Sur QT===
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT. <br\>
Nous avons développé une interface graphique qui permet à un non informaticien de calibrer les Kinects de l’installation. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\><br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\>

----
*Première fenêtre :
La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien s’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
<center>[[Fichier:Mainwindow.PNG]]</center> <br\>
Dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>

MainWindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui
{
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H

MainWindow.cpp :

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent),

ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}

<br\><br\>

----
* Deuxième fenêtre :
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

<center>[[Fichier:Setupcalibration.PNG]]</center><br\>

La fenêtre qui permet la calibration est la suivante :<br\>
<center>[[Fichier:Kinect.PNG]]</center><br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>

----

* Troisième fenêtre:
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
<center>[[Fichier:Fin.PNG]]</center><br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>

Fincalibration.h

#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>

Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:54:55Z

Zassaieb : /* Sur QT */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT est une interface de programmation orientée objet et développée en C++. Elle offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc. Par certains aspects c’est aussi un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des “signaux” et “slots” par exemple.

== Déroulement du projet ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Travail réalisé==
===Sur Unity===

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>

[[Fichier:Unity1.png|vignette|alt=texte alternatif|Scène Unity]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on aie un ‘ground’ (qui correspond à l’écran stéréoscopique) et qui soit parallèle à la scène et aillant les mêmes dimensions que cette dernière, afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>

[[Fichier:Unity2.png|vignette|alt=texte alternatif|Scène résultat]]

----

----

===Sur QT===
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT. <br\>
Nous avons développé une interface graphique qui permet à un non informaticien de calibrer les Kinects de l’installation. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\><br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\>

----
*Première fenêtre :
La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien s’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
[[Fichier:Mainwindow.PNG]] <br\>
Vous trouverez dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>

MainWindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui
{
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H

MainWindow.cpp :

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent),

ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}

<br\><br\>

----
* Deuxième fenêtre :
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

[[Fichier:Setupcalibration.PNG]]<br\>

La fenêtre qui permet la calibration est la suivante :<br\>
[[Fichier:Kinect.PNG]]<br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>

----

* Troisième fenêtre:
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
[[Fichier:Fin.PNG]]<br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>

Fincalibration.h

#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>

Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:43:40Z

Zassaieb : /* Sur QT */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT est une interface de programmation orientée objet et développée en C++. Elle offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc. Par certains aspects c’est aussi un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des “signaux” et “slots” par exemple.

== Déroulement du projet ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Travail réalisé==
===Sur Unity===

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>

[[Fichier:Unity1.png|vignette|alt=texte alternatif|Scène Unity]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on aie un ‘ground’ (qui correspond à l’écran stéréoscopique) et qui soit parallèle à la scène et aillant les mêmes dimensions que cette dernière, afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>

[[Fichier:Unity2.png|vignette|alt=texte alternatif|Scène résultat]]

----

----

===Sur QT===
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT. <br\>

Nous avons développé une interface graphique qui permet à un non informaticien de calibrer les Kinects de l’installation. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\><br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\>

La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien s’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
[[Fichier:Mainwindow.PNG]] <br\>
Vous trouverez dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>

MainWindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui
{
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H

MainWindow.cpp :

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent),

ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}

<br\><br\>
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

[[Fichier:Setupcalibration.PNG]]<br\>

La fenêtre qui permet la calibration est la suivante :<br\>
[[Fichier:Kinect.PNG]]<br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
[[Fichier:Fin.PNG]]<br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>
Fincalibration.h
#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>
Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:36:35Z

Zassaieb : /* Sur Unity */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT est une interface de programmation orientée objet et développée en C++. Elle offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc. Par certains aspects c’est aussi un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des “signaux” et “slots” par exemple.

== Déroulement du projet ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Travail réalisé==
===Sur Unity===

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>

[[Fichier:Unity1.png|vignette|alt=texte alternatif|Scène Unity]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on aie un ‘ground’ (qui correspond à l’écran stéréoscopique) et qui soit parallèle à la scène et aillant les mêmes dimensions que cette dernière, afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>

[[Fichier:Unity2.png|vignette|alt=texte alternatif|Scène résultat]]

----

----

===Sur QT===
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT. <br\>

Nous avons développé une interface graphique qui permet à un non informaticien de calibrer les Kinects de l’installation. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\><br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\>

La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien s’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
[[Fichier:Mainwindow.PNG]] <br\>
Vous trouverez dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>
{
MainWindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H
}
{
MainWindow.cpp :
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
//QMessageBox::information(this,"QUIT","Voulez-vous quitter l'application ?","Non","Oui");
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
}
<br\><br\>
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

[[Fichier:Setupcalibration.PNG]]<br\>

La fenêtre qui permet la calibration est la suivante :<br\>
[[Fichier:Kinect.PNG]]<br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
[[Fichier:Fin.PNG]]<br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>
Fincalibration.h
#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>
Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:35:52Z

Zassaieb : /* Sur Unity */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT est une interface de programmation orientée objet et développée en C++. Elle offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc. Par certains aspects c’est aussi un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des “signaux” et “slots” par exemple.

== Déroulement du projet ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Travail réalisé==
===Sur Unity===

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>

[[Fichier:Unity1.png|vignette|alt=texte alternatif|Scène Unity]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on aie un ‘ground’ (qui correspond à l’écran stéréoscopique) et qui soit parallèle à la scène et aillant les mêmes dimensions que cette dernière, afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>

[[Fichier:Unity2.png|vignette|alt=texte alternatif|Scène résultat]]

===Sur QT===
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT. <br\>

Nous avons développé une interface graphique qui permet à un non informaticien de calibrer les Kinects de l’installation. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\><br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\>

La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien s’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
[[Fichier:Mainwindow.PNG]] <br\>
Vous trouverez dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>
{
MainWindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H
}
{
MainWindow.cpp :
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
//QMessageBox::information(this,"QUIT","Voulez-vous quitter l'application ?","Non","Oui");
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
}
<br\><br\>
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

[[Fichier:Setupcalibration.PNG]]<br\>

La fenêtre qui permet la calibration est la suivante :<br\>
[[Fichier:Kinect.PNG]]<br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
[[Fichier:Fin.PNG]]<br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>
Fincalibration.h
#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>
Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:30:27Z

Zassaieb :

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT est une interface de programmation orientée objet et développée en C++. Elle offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc. Par certains aspects c’est aussi un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des “signaux” et “slots” par exemple.

== Déroulement du projet ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Travail réalisé==
===Sur Unity===

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>
[[Fichier:Unity1.png]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on aie un ‘ground’ (qui correspond à l’écran stéréoscopique) et qui soit parallèle à la scène et aillant les mêmes dimensions que cette dernière, afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>
[[Fichier:Unity2.png]]

===Sur QT===
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT. <br\>

Nous avons développé une interface graphique qui permet à un non informaticien de calibrer les Kinects de l’installation. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\><br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\>

La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien s’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
[[Fichier:Mainwindow.PNG]] <br\>
Vous trouverez dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>
{
MainWindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H
}
{
MainWindow.cpp :
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
//QMessageBox::information(this,"QUIT","Voulez-vous quitter l'application ?","Non","Oui");
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
}
<br\><br\>
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

[[Fichier:Setupcalibration.PNG]]<br\>

La fenêtre qui permet la calibration est la suivante :<br\>
[[Fichier:Kinect.PNG]]<br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
[[Fichier:Fin.PNG]]<br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>
Fincalibration.h
#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>
Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:24:06Z

Zassaieb : /* Les outils matériels/logiciels utilisés */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT est une interface de programmation orientée objet et développée en C++. Elle offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc. Par certains aspects c’est aussi un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des “signaux” et “slots” par exemple.

== Travail réalisé ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Utilisation de Unity==

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>
[[Fichier:Unity1.png]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on est un ‘ground’ (qui correspond à l’écran stéréoscopique) qui soit parallèle à la scène et aillant les mêmes dimensions de cette dernière afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>
[[Fichier:Unity2.png]]

==Utilisation de QT==
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT qui est un API orientée objet et développé en C++ par QT development Frameworks. QT offre des composants d’interface graphiques (widgets), d’accès aux données, de connexions réseaux, de gestion des fils d’exécution, d’analyse XML, etc. <br\><br\>

Nous avons développé une interface graphique qui va permettre à un non informaticien de calibrer les Kinects de l’installation sans devoir modifier dans le code. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\><br\>

La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien c’est juste qu’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
[[Fichier:Mainwindow.PNG]] <br\>
Vous trouverez dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>

MainWindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H

MainWindow.cpp :
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
//QMessageBox::information(this,"QUIT","Voulez-vous quitter l'application ?","Non","Oui");
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

[[Fichier:Setupcalibration.PNG]]<br\>

La fenêtre qui permet la calibration est la suivante :<br\>
[[Fichier:Kinect.PNG]]<br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
[[Fichier:Fin.PNG]]<br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>
Fincalibration.h
#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>
Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:23:01Z

Zassaieb : /* Utilisation de QT */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT

== Travail réalisé ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Utilisation de Unity==

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>
[[Fichier:Unity1.png]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on est un ‘ground’ (qui correspond à l’écran stéréoscopique) qui soit parallèle à la scène et aillant les mêmes dimensions de cette dernière afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>
[[Fichier:Unity2.png]]

==Utilisation de QT==
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT qui est un API orientée objet et développé en C++ par QT development Frameworks. QT offre des composants d’interface graphiques (widgets), d’accès aux données, de connexions réseaux, de gestion des fils d’exécution, d’analyse XML, etc. <br\><br\>

Nous avons développé une interface graphique qui va permettre à un non informaticien de calibrer les Kinects de l’installation sans devoir modifier dans le code. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface. <br\>
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons <br\><br\>

La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien c’est juste qu’il s’est trompé d’application et qu’il voudrait annuler. <br\><br\>
[[Fichier:Mainwindow.PNG]] <br\>
Vous trouverez dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.<br\>

MainWindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H

MainWindow.cpp :
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
//QMessageBox::information(this,"QUIT","Voulez-vous quitter l'application ?","Non","Oui");
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>
Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application. <br\><br\>

[[Fichier:Setupcalibration.PNG]]<br\>

La fenêtre qui permet la calibration est la suivante :<br\>
[[Fichier:Kinect.PNG]]<br\>
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL<br\>

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}
<br\><br\>
En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :<br\>
[[Fichier:Fin.PNG]]<br\>

Voici le code .h et .cpp de cette 3éme fenêtre :<br\>
Fincalibration.h
#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}
<br\>
Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.<br\>
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:20:11Z

Zassaieb : /* Utilisation de Unity */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT

== Travail réalisé ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Utilisation de Unity==

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<br\>
[[Fichier:Unity1.png]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on est un ‘ground’ (qui correspond à l’écran stéréoscopique) qui soit parallèle à la scène et aillant les mêmes dimensions de cette dernière afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>
[[Fichier:Unity2.png]]

==Utilisation de QT==
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT qui est un API orientée objet et développé en C++ par QT development Frameworks. QT offre des composants d’interface graphiques (widgets), d’accès aux données, de connexions réseaux, de gestion des fils d’exécution, d’analyse XML, etc.

Nous avons développé une interface graphique qui va permettre à un non informaticien de calibrer les Kinect de l’installation sans devoir modifier dans le code. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface.
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons

La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien c’est juste qu’il s’est trompé d’application et qu’il voudrait annuler.
[[Fichier:Mainwindow.PNG]]
Vous trouverez dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.

MainWindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H

MainWindow.cpp :
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
//QMessageBox::information(this,"QUIT","Voulez-vous quitter l'application ?","Non","Oui");
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}

Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application.

[[Fichier:Setupcalibration.PNG]]

La fenêtre qui permet la calibration est la suivante :
[[Fichier:Kinect.PNG]]
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}

En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :
[[Fichier:Fin.PNG]]

Voici le code .h et .cpp de cette 3éme fenêtre :
Fincalibration.h
#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}

Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-15T19:19:52Z

Zassaieb : /* Utilisation de Unity */

== Généralités sur le projet ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste à piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

== ==

=== Cahier des charges ===
{{Petit|''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''}}<br\><br\>
-> Mise en place d’un outil de Calibration pour calibrer et mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
* QT

== Travail réalisé ==
===Semaine 03/02 – 07/02===
* Entretien avec Mr Laurent Grisonni pour comprendre le projet
* Etablissement d’un cahier de charge global en attente de précisions après la soutenance des IMA5
* Spécifications des outils et matériels utilisés
===Semaine 10/02 - 14/02===
* Rencontre avec les étudiants qui travaillent déjà sur le sujet
* Compréhension du travail réalisé
* Suggestion d’éventuelles améliorations
===Semaine 17/02 - 21/02===
* Prise en main de l’outil Unity à l’aide de quelques Tutoriels pour la création de scènes 3D
* Compréhension et analyse de la librairie 3gear de détection de geste via la Kinect
===Semaine 03/03 – 07/03===
* Spécification du besoin : Mise en place d’un outil de Calibration pour calibrer mettre en place la scène 3D selon la position de l’utilisateur, pour l’utilisation par un non informaticien.
===Semaine 12/03 – 14/03===
* Installation à l’IRCICA, remise des clefs et badges de la salle de travail, récupération du SVN du projet.
* Rencontre de plusieurs problèmes dont :
o Pas de licence Windows sur le poste fourni 
o Problèmes de réseau et d’accès internet pour l’extraction du SVN

===Semaine 24/03 – 28/03===
* Installation du logiciel Unity
* Impossibilité d’installer les logiciels de programmation pour la librairie 3gear: Processeur incompatible
* Premiers tests du programme existant, incomplets par manque d’outils.
* Ajustements de la scène Unity à la taille de l’écran Stéréoscopique

===Semaine 31/03 – 04/04===
''Outil de calibration'' : Cet outil est censé permettre à l’artiste ou n’importe quel autre utilisateur non information de pouvoir ajuster les réglages et le calibrage des Kinects par rapport à l’écran stéréoscopique sans avoir à modifier les lignes de code de l’application.

''Calibrage'' : Afin de réaliser le calibrage de la Kinect, il faut d’abord lancer les programmes d’installation de la librairie 3gear de la Kinect (nimble_calib et nimble_server, ces applications sont fournies avec le kit de la librairie), il faut ensuite lancer l’application Kinect_MSFT_Calibration. Cette application a été déjà développée pour ce projet et qui consiste en l’affichage de l’image reçue par la Kinect afin de sélectionner dessus les points des 4 coins de l’écran stéréoscopique (l’écran étant visible sur l’image), l’application enregistre alors ces coordonnées dans un fichier texte, et donc, ces coordonnées doivent être repris et mis dans un autre fichier texte en effectuant quelques modifications dessus. Ce dernier est celui qui est utilisé par l’application d’affichage de la scène 3D sur l’écran 3D, et qui utilise ces points pour régler l’affichage.

* Prise en main de l’outil de développement d’interfaces graphiques QT
* Première ébauche de la gestion des fenêtres de l’interface graphique à développer.
* Problème rencontré : l’outil est bloqué quand on affecte à un bouton le passage à une deuxième fenêtre et l’exécution d’une application en même temps.
* Réalisation d’un programme C permettant le transfert des coordonnées du fichier source au fichier de destination.

===Semaine 07/04 – 11/04===
* Test du programme de transfert de données sur l’outil et son implémentation
* Finalisation de l’interface graphique, en résolvant le problème rencontré.
* L’outil réalise bien la tâche demandée.

==Utilisation de Unity==

Au tout début, il fallait ajuster la scène à la taille de l’écran stéréoscopique sous Unity. La scène se présente comme suit :<\br>
[[Fichier:Unity1.png]]
La scène était perpendiculaire à l’écran stéréoscopique. Il fallait l’ajuster de façon à ce qu’on est un ‘ground’ (qui correspond à l’écran stéréoscopique) qui soit parallèle à la scène et aillant les mêmes dimensions de cette dernière afin qu’il n’y ait pas de dépassement de bord.
A travers plusieurs manipulations sous Unity, nous sommes arrivés au résultat suivant :<br\>
[[Fichier:Unity2.png]]

==Utilisation de QT==
Dans cette partie, nous avons utilisé le logiciel de développement d’interface graphique QT qui est un API orientée objet et développé en C++ par QT development Frameworks. QT offre des composants d’interface graphiques (widgets), d’accès aux données, de connexions réseaux, de gestion des fils d’exécution, d’analyse XML, etc.

Nous avons développé une interface graphique qui va permettre à un non informaticien de calibrer les Kinect de l’installation sans devoir modifier dans le code. Tout d’abord, nous avons commencé à nous familiariser au logiciel QT et à son environnement à travers plusieurs tutoriels, ce qui nous a aidés tout au long de notre projet afin de réaliser notre interface.
L’interface graphique de calibration comporte 3 fenêtres. On peut se déplacer d’une fenêtre à l’autre grâce à des boutons

La première fenêtre est la fenêtre typique de chaque installation, qui demande à l’utilisateur s’il veut calibrer sa Kinect ou bien c’est juste qu’il s’est trompé d’application et qu’il voudrait annuler.
[[Fichier:Mainwindow.PNG]]
Vous trouverez dans la suite le code MainWindow.h et MainWindow.cpp de la fenêtre.

MainWindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QApplication>
#include <QProcess>
#include <QtGui>
#include "calibsetup.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();

private slots:

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::MainWindow *ui;
calib *calibsetup;
};

#endif // MAINWINDOW_H

MainWindow.cpp :
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "calibsetup.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QApplication>
#include <QDebug>
#include <QObject>

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::on_pushButton_clicked()
{
calibsetup = new calib;
calibsetup->show();
this->hide();

}

void MainWindow::on_pushButton_2_clicked()
{
//QMessageBox::information(this,"QUIT","Voulez-vous quitter l'application ?","Non","Oui");
QMessageBox msgBox;
msgBox.setWindowTitle("Exit setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}

Le bouton ‘suivant’ permet de continuer l’installation et ainsi de passer à la deuxième fenêtre où on a listé les différentes étapes nécessaires pour la calibration. La calibration se fait via l’application ‘KinectMSFTCalibration’. Pour lancer cette dernière, l’utilisateur a besoin de cliquer sur le bouton ‘commencer’ qui permet d’afficher la vue de la Kinect qui est dirigé vers l’écran stéréoscopique. On pourra par la suite définir les points en cliquant sur F2 puis sur les bords de l’écran en commençant par le bas de l’écran à gauche puis à droite ensuite en haut à droite puis à gauche dans le sens antihoraire. Quand on place les 4 points au bord de l’écran, on définit le plan de définition. F3 nous permet de sauvegarder les coordonnées des points saisie dans un fichier .txt. Quand on clique sur le bouton 'suivant', on exécute un programme qui nous permet de copier ces coordonnées vers un notre fichier texte. Pour pouvoir revenir à la fenêtre calibsetup, il suffit de fermer l’application.

[[Fichier:Setupcalibration.PNG]]

La fenêtre qui permet la calibration est la suivante :
[[Fichier:Kinect.PNG]]
Comme vous l'avez remarqué, on a 3 points au bord de l'écran intitulé dans l'ordre BL - BR - TR - TL

Voici le .h et .cpp de cette fenêtre :

Calibsetup.h :

#ifndef CALIB_H
#define CALIB_H

#include <QDialog>
#include "fincalibration.h"

namespace Ui {
class calib;
}

class calib : public QDialog
{
Q_OBJECT

public:
explicit calib(QWidget *parent = 0);
~calib();

private slots:
void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

private:
Ui::calib *ui;
FinCalibration *fincalib ;
};

#endif // CALIB_H

Calibsetup.cpp :

#include "calibsetup.h"
#include "ui_calibsetup.h"
#include "fincalibration.h"
#include <QMessageBox>

calib::calib(QWidget *parent) :
QDialog(parent),
ui(new Ui::calib)
{
ui->setupUi(this);
}
calib::~calib()
{
delete ui;
}

void calib::on_pushButton_clicked()
{
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_calib.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/nimble_server.bat");
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/tool/KinectMSFTCalibration.exe");
}

void calib::on_pushButton_2_clicked()
{
fincalib = new FinCalibration;
fincalib->show();
this->hide();
system("C:/Users/Demo.ALCOVE-HP-MINT4/Desktop/OOS/Transfert_Points.exe")
;}

void calib::on_pushButton_3_clicked()
{
QMessageBox msgBox;
msgBox.setWindowTitle("Calibration setup");
msgBox.addButton(QMessageBox::Yes);
msgBox.addButton(QMessageBox::No);
msgBox.setText("Voulez-vous vraiment quitter la calibration ?");

int selection = msgBox.exec();
if(selection == QMessageBox::Yes)
{
QCoreApplication::quit();
}
}

En ce qui concerne la 3éme fenêtre, elle permet juste de dire à l’utilisateur que la calibration a été bien faite et que les points ont bien été enregistrés dans le fichier texte puis copier dans le deuxième fichier texte. Voici un imprime écran de la fenêtre :
[[Fichier:Fin.PNG]]

Voici le code .h et .cpp de cette 3éme fenêtre :
Fincalibration.h
#ifndef FINCALIBRATION_H
#define FINCALIBRATION_H

#include <QDialog>

namespace Ui {
class FinCalibration;
}

class FinCalibration : public QDialog
{
Q_OBJECT

public:
explicit FinCalibration(QWidget *parent = 0);
~FinCalibration();

private slots:
void on_pushButton_clicked();

private:
Ui::FinCalibration *ui;

};

#endif // FINCALIBRATION_H

Fincalibration.cpp

#include "fincalibration.h"
#include "ui_fincalibration.h"

#include <QMessageBox>

FinCalibration::FinCalibration(QWidget *parent) :
QDialog(parent),
ui(new Ui::FinCalibration)
{
ui->setupUi(this);
}

FinCalibration::~FinCalibration()
{
delete ui;
}

void FinCalibration::on_pushButton_clicked()
{
QCoreApplication::quit();

}

Pour le bouton ‘annuler’ qui est présent dans toutes les fenêtres, quand on appui dessus, il demande à l’utilisateur s’il veut vraiment quitter la calibration en lui proposant deux boutons « Yes » et « No ». Le bouton « no » permet de revenir à la fenêtre précédente et le bouton « yes » permet de quitter l’application.
[[Fichier:Annuler.PNG]]

Out of Space

2014-04-13T15:19:08Z

Zassaieb : /* Semaine 24/03 – 28/03 */

Out of Space

2014-04-13T15:18:33Z

Zassaieb : /* Les outils matériels/logiciels utilisés */

Out of Space

2014-04-13T15:18:00Z

Zassaieb : /* Cahier des charges */

Out of Space

2014-04-12T17:24:06Z

Zassaieb : /* Semaine 12/03 – 14/03 */

Out of Space

2014-04-12T17:22:14Z

Zassaieb :

Out of Space

2014-02-05T14:35:57Z

Zassaieb : /* Cahier des charges */

Modèle:Petit

2014-02-05T14:06:15Z

Zassaieb : Page créée avec « ''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâche... »

''Le cahier des charges ne peut être réalisé pour l'instant car notre projet est une continuité d'un projet réalisé actuellement par des élèves en IMA5, et les tâches qui nous seront affectées vont dépendre de leur avancement. La phase de transition sera faite quelques jours avant leur soutenance. Cependant, nous avons commencé par nous familiariser aux outils à utiliser''

Out of Space

2014-02-05T13:57:24Z

Zassaieb : /* Descriptif */

Out of Space

2014-02-05T13:52:36Z

Zassaieb : /* Cahier des charges */

Out of Space

2014-02-05T13:52:14Z

Zassaieb : /* Cahier des charges */

Out of Space

2014-02-05T13:48:17Z

Zassaieb :

Out of Space

2014-02-05T13:35:25Z

Zassaieb : /* Les outils matériels/logiciels utilisés */

== Généralités ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

=== Les outils matériels/logiciels utilisés ===

* Kinect, le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.

Out of Space

2014-02-05T13:34:46Z

Zassaieb : /* Les outils matériels/logiciels utilisés */

== Généralités ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

=== Les outils matériels/logiciels utilisés ===

* Kinect le périphérique de reconnaissance de mouvement 
* Ecran Stereoscopique pour l'affichage 3D 
* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java 
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.

Out of Space

2014-02-05T12:17:59Z

Zassaieb : /* Les outils matériels/logiciels utilisés */

Out of Space

2014-02-05T12:16:45Z

Zassaieb :

Modèle:Colonnes

2014-02-05T12:15:46Z

Zassaieb : Page créée avec « * 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en p... »

* 3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java.
* Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.

Out of Space

2014-02-05T12:14:58Z

Zassaieb : Page créée avec « == Généralités == === Contexte === Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application... »

== Généralités ==

=== Contexte ===

Ce projet met en collaboration une artiste et une société de production de jeu vidéo 3D, et vise à mettre en place une application interactive utilisant une classe de dispositifs d'interaction orienté "maquette holographique".

=== Descriptif ===

Le projet vise à réaliser une application interactive sur un affichage stéréoscopique, et qui consiste piloter un objet (une bille) dans un certain environnement, tout en déroulant l’évolution de cet environnement sur une vidéo de fond. Le mouvement de cet objet est contrôlé par les gestes des mains qui sont détectées par une Kinect et traduits sur un écran 3D.

=== Problématique ===

La problématique qui se pose est de pouvoir prendre aussi en compte la tête de l’utilisateur sur l’espace d’acquisition afin d’avoir les données sur l’angle de vision et donc d’orienter l’affichage 3D sur l’écran selon sa position, ainsi le mouvement de la tête impliquera l’inclinaison des objets affichés dans un sens ou dans l’autre.

=== Les outils matériels/logiciels utilisés ===
{{colonnes|nombre=1|
*3Gear possède une technologie qui permet, à partir des caméras 3D de la Kinect, de reconstruire une représentation précise des doigts et de ce que les mains font, en prenant les données 3D brutes et les transformant en informations utilisables sur l'état des mains. Les interfaces de programmation sont basées sur le pointage et le pincement et fournissent les angles des articulations approximatives, elles sont disponibles en C ++, C # et Java.
*Unity 3D est un logiciel middleware de création de contenu interactif comportant de la vidéo et des objets 3D/2D. Il permet de créer des scènes supportant des éclairages, des terrains, des caméras, des textures ... . L’intérêt de ce logiciel est que celui-ci dispose d’une interface intuitive d’intégration d’objets et de scripts ; l’éditeur d’Unity intègre des composants pré-configurés évitant le développement de code fastidieux.
}}

Gestion afficheurs, 2012/2013, TD3

2013-04-30T17:25:19Z

Zassaieb : /* Rapports des élèves */

== Evaluation informatique et électronique ==



=== Gestion de projet / rédaction Wiki ===

* Informatique :
* Electronique :
Note .

=== Test fonctionnels ===

* Sous-système.
** Sous-système informatique :
** Sous-système électronique :

=== Qualité de la réalisation ===

* Informatique : Note .
** procédure de test :
** pages HTML et Javascript :
** scripts PHP ou programmes C :
** installation sur FoxBoard :
* Electronique : Note .
** qualité de la réalisation :
** tests autonomes :

=== Bilan ===

Note finale :

== Rapports des élèves ==





'''Rapport pour la séance du 28/03/2013'''

'''Partie Electronique:'''

Lors de cette première séance de projet, nous avons effectué deux tâches.
Tout d'abord, nous avons appris à nous servir du logiciel Altium grâce à un tutoriel PDF fourni par Mr WICHMANN. Nous avons testé les fonctionnalités du logiciel à l'aide d'un exemple fourni par ce tutoriel.
Enfin, nous avons commencé à mettre en place le schéma électronique et à définir les composants dont nous aurons besoin; parmi eux, des multiplexeurs et démultiplexeurs, des bascules D servant de fonctions mémoires. Nous avons également réfléchi aux connexions que nous devrons utiliser (mise en place des bus de données, des liaisons séries, etc.). Et nous avons finalement créer un premier schéma validé par Mr WICHMANN qui pourrait représenter notre montage. Celui-ci est bien entendu un premier jet à perfectionner.
Durant cette première séance, les principales difficultés rencontrées furent la prise en main d'Altium, car ce fut la première fois que nous utilisions ce logiciel pour cette fonctionnalité. Il a fallu ensuite bien comprendre le système à réaliser pour définir nos objectifs et les techniques à mettre en oeuvre.

'''Partie Informatique:'''

En ce qui concerne la partie informatique, il a fallut tout d'abord comprendre tous les annexes et exemples proposés pour la partie des afficheurs 7 segments, puis essayer de faire un schéma des étapes nécessaires à la conception du programme. Ensuite, nous avons testé l'affichage sur le banc Arduino afin de nous assurer de son bon fonctionnement, nous avons également testé chacun des segments afin de trouver la correspondance entre les bits d'un octet représentant un caractère et les segments des afficheurs.
Ce n'est qu'après que nous avons entamé la réalisation du programme: nous avons commencé par écrire une fonction qui demande un message à l'utilisateur et le charge dans un tableau de caractères, puis une fonction qui convertit chacun de ces caractères alphanumériques à son code afin qu'ils soient affichés sur les segments correspondants. Ces caractères sont ensuite envoyés en série aux 4 afficheurs et défilés à une vitesse d'une seconde par caractère jusqu'à l'affichage du message complet.
La principale difficulté rencontrée est celle de trouver un code à chacun des 36 caractères alphanumériques et les tester un à un pour vérifier l'exactitude du code.

'''Rapport pour la séance du 4/04/2013'''

'''Partie Electronique:'''

Lors de cette deuxième séance nous avons finalisé le schéma sur le logiciel Altium:
[[Fichier:Schema1.png]]

Nous avons branché la Nanobord et apprit à compiler (synthetize + build + program FPGA).
Nous avons débuté les tests sur l'oscilloscope (sans avoir abouti à des résultats satisfaisants), nous avons alors modifié le schéma.

Les problèmes que nous avons rencontré lors des manipulations:
-Connexion entre Altium et la Nanobord
-Beaucoup d'erreurs de compilation au niveau de la programmation de la mémoire(que nous avons réussi à corriger)
-Erreur lors de l'utilisation des bascules D en fonction mémoire donc notre programme ne s'exécute pas comme nous le souhaitons

'''Partie Informatique:'''

Ayant bien avancé lors de la première séance pour la partie informatique, il eut des changements au niveau du cahier de charge.

Pour la deuxième séance, nous sommes passés de l’affichage sur 7 segments à un affichage sur 16 segments, dans ce cas un caractère est représenté par deux mots de 8 bits soit 16 bits au total. Cela demande encore de nouveaux tests, recherche des correspondances entre bits et segments, et une modification de la fonction qui convertit un caractère à un code en changeant les 36 codes de chaque caractère. De plus, au lieu de récupérer le texte à la saisie, nous avons modifié la fonction pour que celle-ci récupère le texte à partir d’un fichier où le message à afficher sera stocké.

Ensuite, nous avons écrit les fonctions qui permettront de contrôler la vitesse de défilement du texte: ralentir ou accélérer, et qui seront exécutées par envoie d’un signal au programme (SIGUSR1 et SIGUSR2) à partir du terminal par la commande « killall –SIGUSR1/2 programme ».

Et enfin, nous avons créé une page html statique, qui contiendra l’interface Web du programme.

'''Rapport pour la séance du 11/04/2013'''

'''Partie Informatique:'''

Cette dernière séance du projet était réservée à la réalisation de la page Web, et des tests finaux.
Dans le fichier html de l’interface Web, nous avons créé une page contenant une zone de texte où sera écrit le message et trois boutons cliquables, l’un pour envoyer le message et deux pour accélérer ou ralentir la vitesse de défilement. Cette page utilisant la bibliothèque JavaScript « jquery .js », nous avons créé les fonctions envoie accélère ou ralenti qui récupèrent l’action et font appels a des scripts PHP. Ensuite, nous avons créé deux fichiers PHP, l’un pour l’envoie du message et son stockage dans le fichier texte utilisé pour récupérer le message et le faire défiler, et l’autre pour gérer la vitesse de défilement en envoyant le signal nécessaire (SIGUSR1 ou SIGUSR2) pour accélérer ou ralentir.
Après que la page Web fut faite, nous avons chargé le programme sur la Foxboard puis fait les tests.
Le programme réalise bien ce qui est demandé.

Gestion afficheurs, 2012/2013, TD3

2013-04-30T17:15:52Z

Zassaieb : /* Rapports des élèves */

== Evaluation informatique et électronique ==



=== Gestion de projet / rédaction Wiki ===

* Informatique :
* Electronique :
Note .

=== Test fonctionnels ===

* Sous-système.
** Sous-système informatique :
** Sous-système électronique :

=== Qualité de la réalisation ===

* Informatique : Note .
** procédure de test :
** pages HTML et Javascript :
** scripts PHP ou programmes C :
** installation sur FoxBoard :
* Electronique : Note .
** qualité de la réalisation :
** tests autonomes :

=== Bilan ===

Note finale :

== Rapports des élèves ==





'''Rapport pour la séance du 28/03/2013'''

'''Partie Electronique:'''

Lors de cette première séance de projet, nous avons effectué deux tâches.
Tout d'abord, nous avons appris à nous servir du logiciel Altium grâce à un tutoriel PDF fourni par Mr WICHMANN. Nous avons testé les fonctionnalités du logiciel à l'aide d'un exemple fourni par ce tutoriel.
Enfin, nous avons commencé à mettre en place le schéma électronique et à définir les composants dont nous aurons besoin; parmi eux, des multiplexeurs et démultiplexeurs, des bascules D servant de fonctions mémoires. Nous avons également réfléchi aux connexions que nous devrons utiliser (mise en place des bus de données, des liaisons séries, etc.). Et nous avons finalement créer un premier schéma validé par Mr WICHMANN qui pourrait représenter notre montage. Celui-ci est bien entendu un premier jet à perfectionner.
Durant cette première séance, les principales difficultés rencontrées furent la prise en main d'Altium, car ce fut la première fois que nous utilisions ce logiciel pour cette fonctionnalité. Il a fallu ensuite bien comprendre le système à réaliser pour définir nos objectifs et les techniques à mettre en oeuvre.

'''Partie Informatique:'''

En ce qui concerne la partie informatique, il a fallut tout d'abord comprendre tous les annexes et exemples proposés pour la partie des afficheurs 7 segments, puis essayer de faire un schéma des étapes nécessaires à la conception du programme. Ensuite, nous avons testé l'affichage sur le banc Arduino afin de nous assurer de son bon fonctionnement, nous avons également testé chacun des segments afin de trouver la correspondance entre les bits d'un octet représentant un caractère et les segments des afficheurs.
Ce n'est qu'après que nous avons entamé la réalisation du programme: nous avons commencé par écrire une fonction qui demande un message à l'utilisateur et le charge dans un tableau de caractères, puis une fonction qui convertit chacun de ces caractères alphanumériques à son code afin qu'ils soient affichés sur les segments correspondants. Ces caractères sont ensuite envoyés en série aux 4 afficheurs et défilés à une vitesse d'une seconde par caractère jusqu'à l'affichage du message complet.
La principale difficulté rencontrée est celle de trouver un code à chacun des 36 caractères alphanumériques et les tester un à un pour vérifier l'exactitude du code.

'''Rapport pour la séance du 4/04/2013'''

'''Partie Electronique:'''

Lors de cette deuxième séance nous avons finalisé le schéma sur le logiciel Altium:
[[Fichier:Schema1.png]]

Nous avons branché la Nanobord et apprit à compiler (synthetize + build + program FPGA).
Nous avons débuté les tests sur l'oscilloscope (sans avoir abouti à des résultats satisfaisants), nous avons alors modifié le schéma.

Les problèmes que nous avons rencontré lors des manipulations:
-Connexion entre Altium et la Nanobord
-Beaucoup d'erreurs de compilation au niveau de la programmation de la mémoire(que nous avons réussi à corriger)
-Erreur lors de l'utilisation des bascules D en fonction mémoire donc notre programme ne s'exécute pas comme nous le souhaitons

'''Partie Informatique:'''

Ayant bien avancé lors de la première séance pour la partie informatique, il eut des changements au niveau du cahier de charge.

Pour la deuxième séance, nous sommes passés de l’affichage sur 7 segments à un affichage sur 16 segments, dans ce cas un caractère est représenté par deux mots de 8 bits soit 16 bits au total. Cela demande encore de nouveaux tests, recherche des correspondances entre bits et segments, et une modification de la fonction qui convertit un caractère à un code en changeant les 36 codes de chaque caractère. De plus, au lieu de récupérer le texte à la saisie, nous avons modifié la fonction pour que celle-ci récupère le texte à partir d’un fichier où le message à afficher sera stocké.

Ensuite, nous avons écrit les fonctions qui permettront de contrôler la vitesse de défilement du texte: ralentir ou accélérer, et qui seront exécutées par envoie d’un signal au programme (SIGUSR1 et SIGUSR2) à partir du terminal par la commande « killall –SIGUSR1/2 programme ».

Et enfin, nous avons créé une page html statique, qui contiendra l’interface Web du programme.

'''Rapport pour la séance du 11/04/2013'''

'''Partie Informatique:'''

Cette dernière séance du projet était réservée pour la réalisation de la page Web, et des tests finaux.
Dans le fichier html de l’interface Web, nous avons créé une page contenant une zone de texte où sera écris le message et trois bouton cliquable, l’un pour envoyer le message et deux pour accélérer ou ralentir la vitesse de défilement. Cette page utilisant la bibliothèque JavaScript « jquery .js », nous avons donc créé les fonctions envoie accélère ou ralenti qui récupèrent l’action et font appels a des scripts PHP. Ensuite, nous avons créé deux fichiers PHP, l’un pour l’envoie du message et son stockage dans le fichier texte utilisé pour récupérer le message et le faire défilé, et l’autre pour gérer la vitesse de défilement en envoyant le signal nécessaire (SIGUSR1 ou SIGUSR2) pour accélérer ou ralentir.
Après que la page Web soit faite, nous avons chargé le programme sur la Foxboard puis fait les tests, le programme réalise bien ce qui est demandé.

Gestion afficheurs, 2012/2013, TD3

2013-04-30T15:54:18Z

Zassaieb : /* Rapports des élèves */

Gestion afficheurs, 2012/2013, TD3

2013-04-30T15:53:48Z

Zassaieb : /* Rapports des élèves */

== Evaluation informatique et électronique ==



=== Gestion de projet / rédaction Wiki ===

* Informatique :
* Electronique :
Note .

=== Test fonctionnels ===

* Sous-système.
** Sous-système informatique :
** Sous-système électronique :

=== Qualité de la réalisation ===

* Informatique : Note .
** procédure de test :
** pages HTML et Javascript :
** scripts PHP ou programmes C :
** installation sur FoxBoard :
* Electronique : Note .
** qualité de la réalisation :
** tests autonomes :

=== Bilan ===

Note finale :

== Rapports des élèves ==





'''Rapport pour la séance du 28/03/2013'''

'''Partie Electronique:'''

Lors de cette première séance de projet, nous avons effectué deux tâches.
Tout d'abord, nous avons appris à nous servir du logiciel Altium grâce à un tutoriel PDF fourni par Mr WICHMANN. Nous avons testé les fonctionnalités du logiciel à l'aide d'un exemple fourni par ce tutoriel.
Enfin, nous avons commencé à mettre en place le schéma électronique et à définir les composants dont nous aurons besoin; parmi eux, des multiplexeurs et démultiplexeurs, des bascules D servant de fonctions mémoires. Nous avons également réfléchi aux connexions que nous devrons utiliser (mise en place des bus de données, des liaisons séries, etc.). Et nous avons finalement créer un premier schéma validé par Mr WICHMANN qui pourrait représenter notre montage. Celui-ci est bien entendu un premier jet à perfectionner.
Durant cette première séance, les principales difficultés rencontrées furent la prise en main d'Altium, car ce fut la première fois que nous utilisions ce logiciel pour cette fonctionnalité. Il a fallu ensuite bien comprendre le système à réaliser pour définir nos objectifs et les techniques à mettre en oeuvre.

'''Partie Informatique:'''

En ce qui concerne la partie informatique, il a fallut tout d'abord comprendre tous les annexes et exemples proposés pour la partie des afficheurs 7 segments, puis essayer de faire un schéma des étapes nécessaires à la conception du programme. Ensuite, nous avons testé l'affichage sur le banc Arduino afin de nous assurer de son bon fonctionnement, nous avons également testé chacun des segments afin de trouver la correspondance entre les bits d'un octet représentant un caractère et les segments des afficheurs.
Ce n'est qu'après que nous avons entamé la réalisation du programme: nous avons commencé par écrire une fonction qui demande un message à l'utilisateur et le charge dans un tableau de caractères, puis une fonction qui convertit chacun de ces caractères alphanumériques à son code afin qu'ils soient affichés sur les segments correspondants. Ces caractères sont ensuite envoyés en série aux 4 afficheurs et défilés à une vitesse d'une seconde par caractère jusqu'à l'affichage du message complet.
La principale difficulté rencontrée est celle de trouver un code à chacun des 36 caractères alphanumériques et les tester un à un pour vérifier l'exactitude du code.

'''Rapport pour la séance du 4/04/2013'''

'''Partie Electronique:'''

Lors de cette deuxième séance nous avons finalisé le schéma sur le logiciel Altium:
[[Fichier:Schema1.png]]

Nous avons branché la Nanobord et apprit à compiler (synthetize + build + program FPGA).
Nous avons débuté les tests sur l'oscilloscope (sans avoir abouti à des résultats satisfaisants), nous avons alors modifié le schéma.

Les problèmes que nous avons rencontré lors des manipulations:
-Connexion entre Altium et la Nanobord
-Beaucoup d'erreurs de compilation au niveau de la programmation de la mémoire(que nous avons réussi à corriger)
-Erreur lors de l'utilisation des bascules D en fonction mémoire donc notre programme ne s'exécute pas comme nous le souhaitons

'''Partie Informatique:'''
Ayant bien avancé lors de la première séance pour la partie informatique, il eut des changements au niveau du cahier de charge.

Pour la deuxième séance, nous sommes passés de l’affichage sur 7 segments à un affichage sur 16 segments, dans ce cas un caractère est représenté par deux mots de 8 bits soit 16 bits au total. Cela demande encore de nouveaux tests, recherche des correspondances entre bits et segments, et une modification de la fonction qui convertit un caractère à un code en changeant les 36 codes de chaque caractère. De plus, au lieu de récupérer le texte à la saisie, nous avons modifié la fonction pour que celle-ci récupère le texte à partir d’un fichier où le message à afficher sera stocké.

Ensuite, nous avons écrit les fonctions qui permettront de contrôler la vitesse de défilement du texte: ralentir ou accélérer, et qui seront exécutées par envoie d’un signal au programme (SIGUSR1 et SIGUSR2) à partir du terminal par la commande « killall –SIGUSR1/2 programme ».

Et enfin, nous avons créé une page html statique, qui contiendra l’interface Web du programme.

'''Rapport pour la séance du 11/04/2013'''

'''Partie Informatique:'''

Gestion afficheurs, 2012/2013, TD3

2013-04-30T15:52:33Z

Zassaieb : /* Rapports des élèves */

== Evaluation informatique et électronique ==



=== Gestion de projet / rédaction Wiki ===

* Informatique :
* Electronique :
Note .

=== Test fonctionnels ===

* Sous-système.
** Sous-système informatique :
** Sous-système électronique :

=== Qualité de la réalisation ===

* Informatique : Note .
** procédure de test :
** pages HTML et Javascript :
** scripts PHP ou programmes C :
** installation sur FoxBoard :
* Electronique : Note .
** qualité de la réalisation :
** tests autonomes :

=== Bilan ===

Note finale :

== Rapports des élèves ==





'''Rapport pour la séance du 28/03/2013'''

'''Partie Electronique:'''

Lors de cette première séance de projet, nous avons effectué deux tâches.
Tout d'abord, nous avons appris à nous servir du logiciel Altium grâce à un tutoriel PDF fourni par Mr WICHMANN. Nous avons testé les fonctionnalités du logiciel à l'aide d'un exemple fourni par ce tutoriel.
Enfin, nous avons commencé à mettre en place le schéma électronique et à définir les composants dont nous aurons besoin; parmi eux, des multiplexeurs et démultiplexeurs, des bascules D servant de fonctions mémoires. Nous avons également réfléchi aux connexions que nous devrons utiliser (mise en place des bus de données, des liaisons séries, etc.). Et nous avons finalement créer un premier schéma validé par Mr WICHMANN qui pourrait représenter notre montage. Celui-ci est bien entendu un premier jet à perfectionner.
Durant cette première séance, les principales difficultés rencontrées furent la prise en main d'Altium, car ce fut la première fois que nous utilisions ce logiciel pour cette fonctionnalité. Il a fallu ensuite bien comprendre le système à réaliser pour définir nos objectifs et les techniques à mettre en oeuvre.

'''Partie Informatique:'''

En ce qui concerne la partie informatique, il a fallut tout d'abord comprendre tous les annexes et exemples proposés pour la partie des afficheurs 7 segments, puis essayer de faire un schéma des étapes nécessaires à la conception du programme. Ensuite, nous avons testé l'affichage sur le banc Arduino afin de nous assurer de son bon fonctionnement, nous avons également testé chacun des segments afin de trouver la correspondance entre les bits d'un octet représentant un caractère et les segments des afficheurs.
Ce n'est qu'après que nous avons entamé la réalisation du programme: nous avons commencé par écrire une fonction qui demande un message à l'utilisateur et le charge dans un tableau de caractères, puis une fonction qui convertit chacun de ces caractères alphanumériques à son code afin qu'ils soient affichés sur les segments correspondants. Ces caractères sont ensuite envoyés en série aux 4 afficheurs et défilés à une vitesse d'une seconde par caractère jusqu'à l'affichage du message complet.
La principale difficulté rencontrée est celle de trouver un code à chacun des 36 caractères alphanumériques et les tester un à un pour vérifier l'exactitude du code.

'''Rapport pour la séance du 4/04/2013'''

'''Partie Electronique:'''

Lors de cette deuxième séance nous avons finalisé le schéma sur le logiciel Altium:
[[Fichier:Schema1.png]]

Nous avons branché la Nanobord et apprit à compiler (synthetize + build + program FPGA).
Nous avons débuté les tests sur l'oscilloscope (sans avoir abouti à des résultats satisfaisants), nous avons alors modifié le schéma.

Les problèmes que nous avons rencontré lors des manipulations:
Connexion entre Altium et la Nanobord
Beaucoup d'erreurs de compilation au niveau de la programmation de la mémoire(que nous avons réussi à corriger)
Erreur lors de l'utilisation des bascules D en fonction mémoire donc notre programme ne s'exécute pas comme nous le souhaitons

'''Partie Informatique:'''
Ayant bien avancé lors de la première séance pour la partie informatique, il eut des changements au niveau du cahier de charge.

Pour la deuxième séance, nous sommes passés de l’affichage sur 7 segments à un affichage sur 16 segments, dans ce cas un caractère est représenté par deux mots de 8 bits soit 16 bits au total. Cela demande encore de nouveaux tests, recherche des correspondances entre bits et segments, et une modification de la fonction qui convertit un caractère à un code en changeant les 36 codes de chaque caractère. De plus, au lieu de récupérer le texte à la saisie, nous avons modifié la fonction pour que celle-ci récupère le texte à partir d’un fichier où le message à afficher sera stocké.

Ensuite, nous avons écrit les fonctions qui permettront de contrôler la vitesse de défilement du texte: ralentir ou accélérer, et qui seront exécutées par envoie d’un signal au programme (SIGUSR1 et SIGUSR2) à partir du terminal par la commande « killall –SIGUSR1/2 programme ».

Et enfin, nous avons créé une page html statique, qui contiendra l’interface Web du programme.

'''Rapport pour la séance du 11/04/2013'''

'''Partie Informatique:'''

Gestion afficheurs, 2012/2013, TD3

2013-04-30T15:51:27Z

Zassaieb : /* Rapports des élèves */

== Evaluation informatique et électronique ==



=== Gestion de projet / rédaction Wiki ===

* Informatique :
* Electronique :
Note .

=== Test fonctionnels ===

* Sous-système.
** Sous-système informatique :
** Sous-système électronique :

=== Qualité de la réalisation ===

* Informatique : Note .
** procédure de test :
** pages HTML et Javascript :
** scripts PHP ou programmes C :
** installation sur FoxBoard :
* Electronique : Note .
** qualité de la réalisation :
** tests autonomes :

=== Bilan ===

Note finale :

== Rapports des élèves ==





'''Rapport pour la séance du 28/03/2013'''

[['''Partie Electronique:''']]

Lors de cette première séance de projet, nous avons effectué deux tâches.
Tout d'abord, nous avons appris à nous servir du logiciel Altium grâce à un tutoriel PDF fourni par Mr WICHMANN. Nous avons testé les fonctionnalités du logiciel à l'aide d'un exemple fourni par ce tutoriel.
Enfin, nous avons commencé à mettre en place le schéma électronique et à définir les composants dont nous aurons besoin; parmi eux, des multiplexeurs et démultiplexeurs, des bascules D servant de fonctions mémoires. Nous avons également réfléchi aux connexions que nous devrons utiliser (mise en place des bus de données, des liaisons séries, etc.). Et nous avons finalement créer un premier schéma validé par Mr WICHMANN qui pourrait représenter notre montage. Celui-ci est bien entendu un premier jet à perfectionner.
Durant cette première séance, les principales difficultés rencontrées furent la prise en main d'Altium, car ce fut la première fois que nous utilisions ce logiciel pour cette fonctionnalité. Il a fallu ensuite bien comprendre le système à réaliser pour définir nos objectifs et les techniques à mettre en oeuvre.

[['''Partie Informatique:''']]

En ce qui concerne la partie informatique, il a fallut tout d'abord comprendre tous les annexes et exemples proposés pour la partie des afficheurs 7 segments, puis essayer de faire un schéma des étapes nécessaires à la conception du programme. Ensuite, nous avons testé l'affichage sur le banc Arduino afin de nous assurer de son bon fonctionnement, nous avons également testé chacun des segments afin de trouver la correspondance entre les bits d'un octet représentant un caractère et les segments des afficheurs.
Ce n'est qu'après que nous avons entamé la réalisation du programme: nous avons commencé par écrire une fonction qui demande un message à l'utilisateur et le charge dans un tableau de caractères, puis une fonction qui convertit chacun de ces caractères alphanumériques à son code afin qu'ils soient affichés sur les segments correspondants. Ces caractères sont ensuite envoyés en série aux 4 afficheurs et défilés à une vitesse d'une seconde par caractère jusqu'à l'affichage du message complet.
La principale difficulté rencontrée est celle de trouver un code à chacun des 36 caractères alphanumériques et les tester un à un pour vérifier l'exactitude du code.

'''Rapport pour la séance du 4/04/2013'''

[['''Partie Electronique:''']]

Lors de cette deuxième séance nous avons finalisé le schéma sur le logiciel Altium:
[[Fichier:Schema1.png]]

Nous avons branché la Nanobord et apprit à compiler (synthetize + build + program FPGA).
Nous avons débuté les tests sur l'oscilloscope (sans avoir abouti à des résultats satisfaisants), nous avons alors modifié le schéma.

Les problèmes que nous avons rencontré lors des manipulations:
Connexion entre Altium et la Nanobord
Beaucoup d'erreurs de compilation au niveau de la programmation de la mémoire(que nous avons réussi à corriger)
Erreur lors de l'utilisation des bascules D en fonction mémoire donc notre programme ne s'exécute pas comme nous le souhaitons

[['''Partie Informatique:''']]
Ayant bien avancé lors de la première séance pour la partie informatique, il eut des changements au niveau du cahier de charge.

Pour la deuxième séance, nous sommes passés de l’affichage sur 7 segments à un affichage sur 16 segments, dans ce cas un caractère est représenté par deux mots de 8 bits soit 16 bits au total. Cela demande encore de nouveaux tests, recherche des correspondances entre bits et segments, et une modification de la fonction qui convertit un caractère à un code en changeant les 36 codes de chaque caractère. De plus, au lieu de récupérer le texte à la saisie, nous avons modifié la fonction pour que celle-ci récupère le texte à partir d’un fichier où le message à afficher sera stocké.

Ensuite, nous avons écrit les fonctions qui permettront de contrôler la vitesse de défilement du texte: ralentir ou accélérer, et qui seront exécutées par envoie d’un signal au programme (SIGUSR1 et SIGUSR2) à partir du terminal par la commande « killall –SIGUSR1/2 programme ».

Et enfin, nous avons créé une page html statique, qui contiendra l’interface Web du programme.

'''Rapport pour la séance du 11/04/2013'''

'''Partie Informatique:'''

Gestion afficheurs, 2012/2013, TD3

2013-04-30T15:49:11Z

Zassaieb : /* Rapports des élèves */

== Evaluation informatique et électronique ==



=== Gestion de projet / rédaction Wiki ===

* Informatique :
* Electronique :
Note .

=== Test fonctionnels ===

* Sous-système.
** Sous-système informatique :
** Sous-système électronique :

=== Qualité de la réalisation ===

* Informatique : Note .
** procédure de test :
** pages HTML et Javascript :
** scripts PHP ou programmes C :
** installation sur FoxBoard :
* Electronique : Note .
** qualité de la réalisation :
** tests autonomes :

=== Bilan ===

Note finale :

== Rapports des élèves ==





'''Rapport pour la séance du 28/03/2013'''

'''Partie Electronique:'''

Lors de cette première séance de projet, nous avons effectué deux tâches.
Tout d'abord, nous avons appris à nous servir du logiciel Altium grâce à un tutoriel PDF fourni par Mr WICHMANN. Nous avons testé les fonctionnalités du logiciel à l'aide d'un exemple fourni par ce tutoriel.
Enfin, nous avons commencé à mettre en place le schéma électronique et à définir les composants dont nous aurons besoin; parmi eux, des multiplexeurs et démultiplexeurs, des bascules D servant de fonctions mémoires. Nous avons également réfléchi aux connexions que nous devrons utiliser (mise en place des bus de données, des liaisons séries, etc.). Et nous avons finalement créer un premier schéma validé par Mr WICHMANN qui pourrait représenter notre montage. Celui-ci est bien entendu un premier jet à perfectionner.
Durant cette première séance, les principales difficultés rencontrées furent la prise en main d'Altium, car ce fut la première fois que nous utilisions ce logiciel pour cette fonctionnalité. Il a fallu ensuite bien comprendre le système à réaliser pour définir nos objectifs et les techniques à mettre en oeuvre.

'''Partie Informatique:'''

En ce qui concerne la partie informatique, il a fallut tout d'abord comprendre tous les annexes et exemples proposés pour la partie des afficheurs 7 segments, puis essayer de faire un schéma des étapes nécessaires à la conception du programme. Ensuite, nous avons testé l'affichage sur le banc Arduino afin de nous assurer de son bon fonctionnement, nous avons également testé chacun des segments afin de trouver la correspondance entre les bits d'un octet représentant un caractère et les segments des afficheurs.
Ce n'est qu'après que nous avons entamé la réalisation du programme: nous avons commencé par écrire une fonction qui demande un message à l'utilisateur et le charge dans un tableau de caractères, puis une fonction qui convertit chacun de ces caractères alphanumériques à son code afin qu'ils soient affichés sur les segments correspondants. Ces caractères sont ensuite envoyés en série aux 4 afficheurs et défilés à une vitesse d'une seconde par caractère jusqu'à l'affichage du message complet.
La principale difficulté rencontrée est celle de trouver un code à chacun des 36 caractères alphanumériques et les tester un à un pour vérifier l'exactitude du code.

'''Rapport pour la séance du 4/04/2013'''

'''Partie Electronique:'''

Lors de cette deuxième séance nous avons finalisé le schéma sur le logiciel Altium:
[[Fichier:Schema1.png]]

Nous avons branché la Nanobord et apprit à compiler (synthetize + build + program FPGA).
Nous avons débuté les tests sur l'oscilloscope (sans avoir abouti à des résultats satisfaisants), nous avons alors modifié le schéma.

Les problèmes que nous avons rencontré lors des manipulations:
Connexion entre Altium et la Nanobord
Beaucoup d'erreurs de compilation au niveau de la programmation de la mémoire(que nous avons réussi à corriger)
Erreur lors de l'utilisation des bascules D en fonction mémoire donc notre programme ne s'exécute pas comme nous le souhaitons

'''Partie Informatique:'''

Ayant bien avancé lors de la première séance pour la partie informatique, il eut des changements au niveau du cahier de charge.
Pour la deuxième séance, nous sommes passés de l’affichage sur 7 segments à un affichage sur 16 segments, dans ce cas un caractère est représenté par deux mots de 8 bits soit 16 bits au total. Cela demande encore de nouveaux tests, recherche des correspondances entre bits et segments, et une modification de la fonction qui convertit un caractère à un code en changeant les 36 codes de chaque caractère. De plus, au lieu de récupérer le texte à la saisie, nous avons modifié la fonction pour que celle-ci récupère le texte à partir d’un fichier où le message à afficher sera stocké.
Ensuite, nous avons écrit les fonctions qui permettront de contrôler la vitesse de défilement du texte: ralentir ou accélérer, et qui seront exécutées par envoie d’un signal au programme (SIGUSR1 et SIGUSR2) à partir du terminal par la commande « killall –SIGUSR1/2 programme ».
Et enfin, nous avons créé une page html statique, qui contiendra l’interface Web du programme.

'''Rapport pour la séance du 11/04/2013'''

'''Partie Informatique:'''

Gestion afficheurs, 2012/2013, TD3

2013-04-03T17:11:02Z

Zassaieb : /* Rapports des élèves */

Projets troisième année, 2012/2013, TD3

2013-03-28T07:33:33Z

Zassaieb : /* Répartition des binômes */

== Répartition des binômes ==

Ecrivez vos noms sous le format exact "Prénom Nom", séparez vos noms par des virgules.

{| class="wikitable"
! Projet !! Elèves
|-
| [[Contrôle de matrice leds, 2012/2013, TD3]] || Oumaima Bekraoui, Florian Caron, Demba Fall, Quentin Pesqueux
|-
| [[Communication série, 2012/2013, TD3]] ||wu shuyun yuchao luo simon duthoit émile pinet
|-
| [[Gestion afficheurs, 2012/2013, TD3]] || jebbari zineb assaieb zohour vantom eddy
|-
| [[Gestion de LED RVB, 2012/2013, TD3]] ||
|-
| [[Contrôle de sonar, 2012/2013, TD3]] || Adnane JAOUI, Ismail ZIOU, Oussama HAMZAOUI, Smaïn LABDOUNI
|-
| [[Contrôle d'accéléromètre, 2012/2013, TD3]] || Mélanie Hautecoeur, Ismail Tahry, Geoffrey Bruno, Simon Malthieu
|-
| [[Contrôle de bras robotique, 2012/2013, TD3]] || Jérome Vaessen, Cédric Desprez, Jamal Chamane, Mathieu Bossennec
|}