rapport final version 1 luc jager .pdf


À propos / Télécharger Aperçu
Nom original: rapport_final_version_1_luc_jager.pdf

Ce document au format PDF 1.5 a été généré par LaTeX with hyperref / pdfTeX-1.40.23, et a été envoyé sur fichier-pdf.fr le 28/11/2022 à 18:05, depuis l'adresse IP 82.64.x.x. La présente page de téléchargement du fichier a été vue 2 fois.
Taille du document: 8.7 Mo (32 pages).
Confidentialité: fichier public


Aperçu du document


Jumeau numérique d’usine et simulation des activités
des travailleurs

Compte rendu de stage de fin d’étude : Master I3D
Projet VIRTFac
Luc Jager

Encadré par :
Thierry Blandet, Quentin Misslin et Jérôme Grosjean
Tuteur universitaire :
Benoit NAEGEL

Master 2 Image et 3D

Semestre Automne 2021
Page 1/32

22 août 2022

Remerciement

Je tenais à remercier Thierry Blandet et Quentin Misslin pour leur aide apportée durant mon
stage. Ils m’ont toujours bien conseillé tout au long du projet. On avait une bonne organisation
et un suivi de près.
Je voulais aussi remercier mes collèges stagiaires Aymeric, Victor, Romaric et Hugo. J’ai travaillé
avec eux dans une superbe ambiance et une belle cohésion d’équipe se ressentait. J’ai passé de
bons moments avec eux.
Enfin, je remercie toutes les autres personnes travaillant sur le projet de VIRTFac de près ou de
loin, ce fut un plaisir. Merci à tout le monde, que ce soit dans l’équipe IGG et ICube en général.
J’ai appris beaucoup durant ce stage et ce fut très enrichissant pour moi. C’est une belle façon
de terminer ce master.

Page 2/32

22 août 2022

Table des matières
1 Mise en contexte
1.1 Contexte VirtFac . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1.1 Laboratoire ICube et équipe de recherche IGG . . . . . .
1.1.2 Modèle numérique, ombre numérique, jumeau numérique
1.1.3 L’infrastructure logiciel de VIRTFAC . . . . . . . . . . .
1.2 Objectifs du stage . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 Outils et technologies utilisés . . . . . . . . . . . . . . . . . . . .
1.3.1 Réalité virtuelle : Meta quest 2 . . . . . . . . . . . . . . .
1.3.2 Unreal Engine . . . . . . . . . . . . . . . . . . . . . . . .
1.3.3 Vue.JS avec vuetify : côté client . . . . . . . . . . . . . . .
1.3.4 NodeJS : côté serveur . . . . . . . . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

4
4
4
6
7
8
10
10
10
10
11

2 Travail réalisé
2.1 Importateur glTF . . . . . . . . . . . . . . . . . .
2.1.1 Comprendre la structure . . . . . . . . . .
2.1.2 Parser le fichier . . . . . . . . . . . . . . .
2.1.3 Les materials . . . . . . . . . . . . . . . .
2.1.4 Le format binaire, le GLB . . . . . . . . .
2.1.5 Extensions du glTF . . . . . . . . . . . .
2.2 Menu : Vue.JS avec vuetify . . . . . . . . . . . .
2.2.1 Utiliser une technologie web dans Unreal
2.3 Gestionnaire des objets . . . . . . . . . . . . . . .
2.3.1 La structure . . . . . . . . . . . . . . . . .
2.4 Gestionnaire de scène . . . . . . . . . . . . . . .
2.4.1 La structure . . . . . . . . . . . . . . . . .
2.5 Serveur VIRTFac Real Time . . . . . . . . . . . .
2.5.1 Système de socket . . . . . . . . . . . . .
2.5.2 Créer, rejoindre et quitter des salles . . .
2.6 OPC UA . . . . . . . . . . . . . . . . . . . . . .
2.6.1 Serveur opc ua . . . . . . . . . . . . . . .
2.6.2 Client opc ua . . . . . . . . . . . . . . . .
2.6.3 Profils et évènements . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

12
12
12
13
14
16
18
19
19
20
21
21
22
24
24
24
25
25
25
25

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

3 Autre évènements
28
3.1 L’inaugurarion de l’école-usine d’Haguenau . . . . . . . . . . . . . . . . . . . . . 28
3.2 La présentation pour Confere22 à Bâles . . . . . . . . . . . . . . . . . . . . . . . 28
4 Conclusion

29

5 Lexique

30

Page 3/32

22 août 2022

1

Mise en contexte

Ce projet entre dans le cadre du projet VIRTFac [17]. Il est l’un des modules nécessaires à la
réalisation du jumeau numérique d’usine (voir lexique5). Je travaillerai principalement sur
Ergonomio et sur VIRTFac Real Time.

1.1

Contexte VirtFac

VIRTFac [17] (Virtual Innovative Real Time Factory) a pour mission le développement d’une
plateforme web d’usine virtuelle dont la fonction est d’une part d’accompagner les entreprises à
divers degrés de maturité dans la planification de l’évolution de leur système de production, et
d’autre part d’aborder les problématiques de recherche associées à l’usine virtuelle et aux
nouvelles techniques d’information.
Le projet VIRTFac est un projet européen Interreg [8]. Il est porté par l’INSA de Strasbourg [4],
les autres partenaires académiques sont l’Université de Strasbourg et la Hochschule Offenburg.
Ce stage s’inscrit dans la continuité du projet de TER [1] que j’ai mené l’an dernier, du stage
durant l’été dernier et du projet master que j’ai effectué le semestre dernier.
Ergonom.io est une application de réalité virtuelle qui, à partir de la numérisation de l’usine et
de la numérisation des gestes va permettre l’analyse des postures et des mouvements des
opérateurs pour permettre leur amélioration pour la prévention des TMS (Troubles
musculo-squelettiques, voir lexique5) et aussi permettre la correction de l’ergonomie de leurs
postes de travail [10].
Par ailleurs cette application va simuler des activités humaines et suivre en temps réel le
fonctionnement d’une ligne de production. Cette application va également inclure des outils de
visualisation en réalité virtuelle des simulations dynamiques à partir de flux de données issues
de Witness (voir lexique5) ou de Plant Simulation qui seront traités comme les flux issus de la
ligne de production.
1.1.1

Laboratoire ICube et équipe de recherche IGG

Pour mon stage de fin d’étude, je travaille dans l’équipe IGG [16] au laboratoire ICube. ICube
est un laboratoire des sciences de l’ingénieur, de l’informatique et de l’imagerie basé à
Strasbourg. L’année 2013 voit la naissance du laboratoire ICube, un formidable projet sous
l’égide du CNRS, de l’Université de Strasbourg, de l’ENGEES et de l’INSA de Strasbourg.
Le laboratoire rassemble à parts égales deux communautés scientifiques à l’interface entre le
monde numérique et le monde physique, lui donnant ainsi une configuration unique. Avec près
de 650 membres, il est une force de recherche majeure du site de Strasbourg. Fédéré par
l’imagerie, ICube a comme champs d’application privilégiés l’ingénierie pour la santé,
l’environnement et le développement durable.

Page 4/32

22 août 2022

Figure 2 : Organisation du laboratoire ICube

L’équipe IGG (Informatique Géométrique et Graphique) s’est donnée pour objectif de définir
des modèles géométriques efficaces, prenant en compte la nature variée des données considérées
(contraintes, images médicales, numérisation, capture du mouvement), pour concevoir,
reproduire la forme, l’apparence et le mouvement des objets 3D afin de les visualiser, les simuler
et d’interagir avec eux de manière précise dans des environnements virtuels.
Ces objectifs se déclinent autour de quatre thèmes complémentaires :
— Géométrie 3D et Animation
— Interaction Homme-Machine et Réalité Virtuelle
— Spécifications et Preuves en Géométrie
— Textures, Rendu et Visualisation
Nous sommes dans la partie réalité virtuelle avec comme responsable Thierry Blandet secondé
de Quentin Misslin. Thierry est le responsable général du projet, il est ingénieur dans l’équipe.
Quentin Misslin est un ancien étudiant du master, il travaille depuis 2 ans en tant qu’ingénieur
dans l’équipe IGG.
L’équipe IGG est partenaire en particulier en charge de la partie réalité virtuelle pour l’analyse
de l’ergonomie de postes de travail (Simulation ergonomique des activités du travailleur), de la
simulation et de la restitution de jumeaux virtuels d’ateliers de production. Le projet envisage
l’expérimentation des outils de réalité virtuelle sur l’usine-école de Haguenau puis leur
validation sur des cas réels proposés par les partenaires industriels.

Page 5/32

22 août 2022

1.1.2

Modèle numérique, ombre numérique, jumeau numérique

La première notion à préciser est celle qui est employée régulièrement, celle de jumeau
numérique. De nombreuses définitions tentent de préciser ce qu’est un jumeau numérique et il
est clair que la notion de « réplique numérique » est insuffisante et nous conserverons l’idée
initiale de Michael Grieves de 2002 [6] [5].
Nous allons préciser les notions de modèle numérique, ombre numérique, et jumeau numérique 3.
Dans le modèle numérique l’échange de données entre le physique et le modèle numérique ne
sont pas automatiques. Tous les échanges se font manuellement, aucune modification de l’état
du physique ou du modèle numérique n’a de conséquences directes sur l’autre. Dans l’ombre
numérique, un changement dans l’objet physique peut entraîner une modification automatique
du numérique.
Enfin pour le jumeau numérique, il existe un flux de données entre la composante physique et le
numérique et vice versa. Le physique peut contrôler le numérique, tout comme le numérique
peut intervenir dans le physique. Ce flux constant complètement intégré est nécessaire pour
définir ce qu’est un jumeau numérique [3]. Parfois le concept de jumeau numérique est utilisé à
tort par exemple quand on parle de jumeau numérique des océans : on peut faire des
simulations, recueillir des données pour piloter un modèle numérique mais il est évidemment
impossible en retour d’agir sur l’océan.

Figure 3 : Modèle numérique, ombre numérique et jumeau numérique

Contrairement à la simulation classique, le jumeau numérique fournit en temps réel des
informations sur l’état actuel de fonctionnement du système réel auquel il est associé pour en
créer une représentation dynamique. Ces informations proviennent de différents types de
capteurs ou de données issues des logiciels de gestion de l’usine. Le jumeau numérique va servir
à la formation, à l’organisation et à l’optimisation d’une ligne de production, à améliorer des
processus de fabrication et prévenir des défaillances, des pannes, des usures, des défauts de
fabrication pour prévoir et programmer les interventions de maintenance.
Le jumeau numérique couvre des besoins qui peuvent être très différents, en fonction du système
physique concerné, des données recueillies (capteurs, IOT), des résultats du traitement des
données, de la numérisation de l’entreprise, de son activité, etc. Dans nos développements, nous
avons pu valider le transfert de données et leur traitement depuis une ligne de production mais
la fermeture des systèmes ou l’impossibilité d’un pilotage externe nous a empêchés de valider le
concept de jumeau numérique.

Page 6/32

22 août 2022

1.1.3

L’infrastructure logiciel de VIRTFAC

L’objectif du projet est de proposer des outils capables de répondre aux besoins de numérisation
de l’industrie de demain 4. Pour cela les entreprises, petites ou grandes, devront se doter
d’équipements matériels, d’outils connectés et de logiciels capables de simuler et de traiter leurs
données pour améliorer leur flexibilité et leur productivité. L’humain qui est au centre des
préoccupations des managers est une partie importante de notre projet.
Nous considérons la prise en compte de la santé au travail et l’objectif de diminution du nombre
de TMS par l’analyse des gestes des opérateurs et de la qualité ergonomique des postes de
travail. Cette analyse est effectuée a posteriori ou dans la phase de conception des postes. Nous
souhaitons accompagner les entreprises dans leur passage à l’industrie 4,0 [9].
Certaines ont adopté des logiciels de type MES (voir lexique5) ou ERP (voir lexique5). Les
logiciels de pilotage de la production, ou MES (Manufacturing Execution System) sont des
systèmes qui permettent de gérer et de suivre la production en temps réel. Ces Logiciels créent
un lien numérique entre l’atelier de production et les logiciels de gestion d’entreprise (ERP,
Enterprise Resource Planning). L’ERP, véritable « colonne vertébrale » d’une entreprise, est un
progiciel qui permet de gérer l’ensemble des processus opérationnels d’une entreprise : la gestion
des commandes, les stocks, la paie, la comptabilité, la production. Nous avons créé des
passerelles à partir et vers ces outils permettant de traiter en temps réel des données issues des
lignes de production (capteurs, IoT).

Figure 4 : L’infrastructure applicative de VIRTFAC

Les données stockées et échangées dans VIRTFac sont :
— Des modèles 3D (CAO (voir lexique5), numérisation ou modélisation) stockées en JSON
(voir lexique5)
— Des données de capture de mouvement
— Des données utilisateurs (profils, avatars virtuels, comptes, système de gestion de groupe,
de compte etc.)
— Des données brutes formatées (issues de tableurs ou d’export d’applications tierces)
— Des données de communication temps réel (issues de capteurs ou par exemple lors de
l’utilisation d’Ergonom.io en mode collaboratif)
Page 7/32

22 août 2022

Figure 5 : L’infrastructure de VIRTFAC plus détaillée

Sur la figure 5, on peut voir des sections plus détaillées. En premier lieu, j’ai effectué différents
tests de communication pour finaliser ce que j’avais fait en projet master concernant l’ERP
Odoo. Cela concerne la partie ERP et VIRTFac ERP. J’ai aussi un peu travaillé sur Data
Formatting en utilisant KNIME mais on a très vite abandonné cette solution. En deuxième lieu,
je travaillerais sur Ergonomio.io en équipe avec Aymeric. Ensuite, je développerai seul VIRTFac
Real Time et m’occuperai de toutes les communications entrantes et sortantes, des différentes
données ainsi que de l’infrastructure du serveur. Je travaillerai aussi entièrement sur Production
Line Connector avec notamment à gérer un autre serveur, un client et le protocole opc ua. Il
faut aussi, en terme de compatibilité, pouvoir prendre en charge certains MES.

1.2

Objectifs du stage

L’objectif principal du stage est de développer une solution pour créer le jumeau numérique
d’une usine. On a priorisé les développements pour avoir une solution pour l’ombre numérique.
Cette solution sera ainsi proposer à des petites ou moyennes entreprises plus communément
appelé PME.
Pour créer ce fameux jumeau numérique, plusieurs problèmes se posent. Tout d’abord, comment
modéliser notre usine virtuelle. Pour cela, il faut une application permettant de créer le plan de
cette usine. Ce développement a été fait par un stagiaire : Romaric. Une fois le plan fait, il faut
passer ce plan 2D en 3D.
Ensuite, il faut venir placer les différents objets de notre usine comme des chaises, des tables ou
des machines. Ces objets doivent être réalistes pour correspondre au mieux à notre usine.
On va utiliser le glTF [2] : c’est un format de fichier scènes et modèles 3D utilisant le format
JSON. Le but de glTF est d’être un format compact, interopérable, et rapide à charger.
Page 8/32

22 août 2022

L’objectif étant de pouvoir récupérer un glTF, de l’interpréter dans Unreal Engine [15] et de
pouvoir faire des modifications diverses et variées. Ces fichiers glTF représentant nos objets
seront stockés sur le serveur API VIRTFac (voir lexique5). Ainsi, il suffira de connecter le client
au serveur pour qu’il ait accès à toutes les ressources dont il a besoin.
Une petite idée de l’écosystème du glTF ainsi que de son support :

Figure 6 : Écosystème du glTF

Figure 7 : Industrie et support du glTF

Une fois cela fait, il faut maintenant pouvoir communiquer de l’usine réelle vers l’usine virtuelle.
Pour cela, on a différents capteurs qui vont nous envoyer des informations en temps réels. Ces
informations sont envoyer via le protocole OPC-UA [7], qui est un protocole d’usine industrielle.
On aura besoin d’un serveur pour récupérer les données en temps réels et les traiter. Ce serveur
sera différent du serveur API VIRTFac. En effet, son but est de traiter des données en temps
réels.
Enfin, il faut croiser les données des différents logiciels et de les exploiter pour améliorer
Page 9/32

22 août 2022

l’ergonomie et la productivité. Les données issues des lignes de production et les données issues
des systèmes de gestions (ERP, MES) sont stockées dans une base de donnée.

1.3

Outils et technologies utilisés

Pour réaliser les différents développements pour le projet de VIRTFac, j’ai eu accès à différents
outils. Que ce soit des outils physiques ou virtuels, il a fallu que je me familiarise durant tout
mon stage de master. Par le passé, j’ai déjà travaillé avec certains outils utilisés notamment de
réalité virtuelle.
Remarque : j’ai à ma disposition un ordinateur sous Windows 10 pour les différents
développements.
1.3.1

Réalité virtuelle : Meta quest 2

Mes développements sont accompagnés d’un casque de réalité virtuelle : le Meta quest 2 [14],
anciennement l’Oculus quest 2. Il est le successeur du Quest. C’est un casque qui fonctionne :
— soit branché à l’ordinateur en utilisant la puissance de la machine
— soit de façon autonome sans branchement
Avec celui-ci, je vais venir tester les différentes applications que je fais. Chaque développement
dans Unreal est testé pour voir sa compatibilité en réalité virtuelle et faire des ajustements si
nécessaire.
Le but final étant que l’application soit fonctionnel à la fois sur un ordinateur classique en
clavier/souris que sur un casque de réalité virtuelle.
1.3.2

Unreal Engine

Unreal Engine [15] est le moteur de jeu 3D utilisé pour tous nos développements 3D. Il a été
développé par Epic Games et permet la création d’applications multiplateformes en 2D ou en
3D. Il est très connu et puissant. C’est un logiciel très complexe et difficile à prendre en main au
début.
C’est un logiciel possédant différentes bibliothèques haut niveau et un très grand nombre de
fonctionnalités. Il permet de concevoir plus facilement des logiciels 2D ou 3D grâce à divers
algorithmes déjà implémentés en son sein. Il peut gérer la physique, les animations, le rendu 3D,
les shaders, etc... Unreal utilise un système de blueprint permettant de coder de façon visuelle.
Les blueprints ne sont rien d’autre que du code C++ compilés. On utilise aussi le langage C++
pour créer nos classes et nos objets.
Début 2021, nous avons choisi d’utiliser Unreal Engine. Ce choix a été fait suite à de nombreux
problèmes de compatibilité entre les différentes versions de Unity. Unity est aussi un moteur de
jeu 3D populaire, c’est l’ancien moteur que nous utilisions. Nous avions eu des difficulté pour
maintenir du code ou encore faire des portages entre les versions. Nous avons donc opter pour
Unreal Engine qui est beaucoup plus stable entre les différentes versions.
1.3.3

Vue.JS avec vuetify : côté client

Vue.js, est un framework JavaScript open-source utilisé pour construire des interfaces utilisateur
et des applications web monopages. Le framework est notamment utilisée par des grands
groupes comme Adobe, Alibaba et GitLab.
Page 10/32

22 août 2022

Nous nous sommes tourné vers Vue.JS [12] pour son architecture stricte et sa facilité pour
réutiliser du code. C’est un très bon choix pour travailler en équipe sur un projet car on doit
rigoureusement respecter notre façon de programmer. En effet : Aymeric, Romaric, Quentin et
moi-même avons dû bosser ensemble avec cette technologie.
De plus, nous utilisons Vuetify [13]. Vuetify est un framework de composants d’interface
utilisateur construit au-dessus de Vue.JS. Basé sur la spécification Material Design créé et
utilisé par Google, il fournit aux développeurs les outils dont ils ont besoin pour créer des
interfaces utilisateur riches et attrayantes.
1.3.4

NodeJS : côté serveur

Pour l’aspect collaboratif, il nous fallait un serveur où les différentes données en temps réels
circulerait. Grâce à ce serveur, nous pourrions créer des salles collaboratives où plusieurs
personnes pourrait être connecter en même temps. Chaque salle sera reliée à une scène et
enregistrer dans notre base de donnée.
Nous avons choisi Node.js [11] pour créer le serveur. C’est un choix populaire pour les
développeurs construisant un backend flexible et évolutif est sa nature événementielle et non
bloquante. Nous pourrions donc traiter les données de façon asynchrone, ce qui est parfait pour
gérer plusieurs requêtes et client en même temps.
Notre serveur nodeJS servira pour la création de salle. On pourra les rejoindre ainsi que les
supprimer. On aura un lobby en tant que menu pour voir les différentes salles et y accéder. Il
partagera aussi les différentes informations sur les joueurs comme la position ou encore l’avatar
des joueurs.
Notre serveur servira aussi pour la réception des données en temps réels opc ua depuis le client
opc ua. Ainsi, on pourra « jouer » les données dans une scène : comme par exemple bouger un
convoyeur ou allumer une lumière.

Page 11/32

22 août 2022

2

Travail réalisé

2.1

Importateur glTF

La création d’un importateur glTF (GL Transmission Format) a été le commencement de mon
stage. Le choix du glTF a été fait par Quentin. Cela aidera à répondre au problème du
placement des différents objets 3D pour reconstituer l’usine réelle en virtuelle de la meilleure des
façons. J’ai travaillé en collaboration avec Aymeric Schauli, un autre stagiaire employé dans
l’équipe IGG.
Le but est de comprendre la structure du format glTF puis de pouvoir retranscrire les différentes
informations pour créer un procedural mesh (voir lexique5) dans Unreal Engine. Il a fallu parser
le fichier pour récupérer les données et les appliquer à notre mesh en temps réel. Pour la
répartition du travail, j’ai travaillé sur la partie material tandis qu’Aymeric a travaillé sur la
partie mesh. Nous avons travaillé aussi sur les skeletal mesh ensemble et Aymeric a améliorer le
travail par la suite. Enfin, j’ai aussi pris en charge le GLB, qui est la version binaire du glTF.
Un fichier 3D glTF embarque les informations suivantes :
— Le maillage 3D
— Les matériaux
— Les textures
— L’arborescence
— Le squelette
— L’animation
— Les lumières avec une extension
2.1.1

Comprendre la structure

Comprendre la structure glTF est essentiel pour parser correctement le fichier et récupérer les
données correspondantes pour les appliquer par la suite.
Voici un schéma de la structure du glTF :

Figure 8 : Structure du glTF

Page 12/32

22 août 2022

Comme nous pouvons le voir, la structure est représentée comme un arbre. Chaque noeud
pointe soit sur lui même soit sur un noeud inférieur. Par exemple, mesh pointe vers material et
accessor. Chaque section a un certain rôle, material comme son nom l’indique s’occupe de la
partie des matérials et des textures de l’objet.
Pour la stockage des données, la plupart sont dans le buffer. En effet, chaque section pointe vers
un indice du bufferview. Le bufferview lui même va pointer vers l’endroit où se trouve les
données avec la longueur correspondante. Cela permet d’éviter de faire de la redondance. On
peut voir que pour accéder au bufferview, on passe par l’accessor. C’est par là, qu’on devrait
passer à chaque fois qu’on voudra récupérer des données.
2.1.2

Parser le fichier

Voici un exemple simple d’un fichier gltf :

Figure 9 : Fichier gltf simple

Pour parser le fichier, j’ai utilisé le c++ plutôt que les blueprints car il est plus adapté pour
manipuler du bas niveau. Nous avons utilisé une bibliothèque inclue par défaut dans Unreal
pour traiter les données obtenues. Celle-ci permet de parser les données JSON pour récupérer
les informations sur la structure. Contrairement à des formats 3D plus classiques, le glTF
contient beaucoup d’informations sur notre objet.
Pour chaque noeud, nous avons créé un fichier c++ et son header correspondant à sa structure.
Par exemple, pour l’accessor nous avons un fichier accessor.cpp pour les différentes fonctions de
recherche liées à l’accessor. Nous avons aussi un fichier accessor.h pour reproduire les différentes
structures et les réutiliser au sein de notre application. Nous avons donc reproduis la structure
dans le c++ pour l’utiliser par la suite et rester cohérent.
Chacun des fichiers est reliés comme dans la structure glTF. Si je voudrais accéder au buffer, il
faut que je passe par la classe accessor puis bufferView et enfin buffer. Nous avons voulu au
mieux reproduire la structure pour respecter une certaine cohérence.
Le but est de récupérer les données de notre objet glTF afin de créer un objet dans Unreal. La
structure de donnée utilisée par Unreal pour la représentation de maillage est simpliste :
— Un tableau de Vector3 pour les coordonnées 3D des sommets
— Un tableau de Vector3 pour les normales des sommets
Page 13/32

22 août 2022

— Un tableau de Vector2 pour les UVs qui serviront pour placer la texture sur l’objet
— Un tableau d’entiers contenant les indices des sommets des triangles.
Nous allons nous servir d’un procedural mesh component pour représenter notre objet. Il peut
être composer de plusieurs sections, appelés meshSections, pour pouvoir appliquer différents
matériaux. Nous avons créer une classe MyProceduralMesh permettant de créer des procedural
mesh à l’aide de différents paramètres. Il y a les coordonnées dans l’espace des sommets, les
normales des sommets, les UVs, etc... Mon objectif était de récupérer les materials du glTF pour
les utiliser dans notre procedural mesh.
2.1.3

Les materials

Dans la vie, les objets ont des matières différentes que nous appelons ici material. La matière est
une substance ou un mélange de substances qui constitue un objet. Un material, c’est un asset
qui contrôle l’apparence d’un objet dans notre niveau. Par exemple, il permet de modifier la
couleur de l’objet ou encore sa rugosité. Toutes ces modifications changeront l’apparence de
notre objet.
Dans Unreal, nous allons utiliser le PBR (Physically Based Materials). Il a pour but de
reproduire au mieux les comportements réels des lumières sur les différentes surfaces. En
d’autres termes, il s’agit de simuler la réalité en appliquant des techniques d’ombrages basées
sur des lois de la physique.
Le PBR inclut quatre principales propriétés qu’Epic Games a surnommé :
— Base Color (albédo) : comme son nom l’indique, son but est de fournir la couleur de votre
material
— Roughness : ce paramètre contrôle la netteté (rugosité) de la surface
— Metallic : celui-ci a pour but de contrôler le taux de métal sur votre surface
— Specular : permet de contrôler la réflexion spéculaire telles que la lumière sur une surface
Voici une exemple de la structure des materials :

Page 14/32

22 août 2022

Figure 10 : Tableau explicatif officiel

Remarque : extensions et extras ne nous intéressent pas ici.
Pour récupérer la structure, il y a deux méthodes. Soit la texture est directement en brute dans
image, soit il y a une référence vers un bufferview. Il faut ensuite convertir la structure. Celle-ci
en base64 et il nous l’a faut en JSON pour pouvoir l’utiliser. C’est là que le sampler est utile, il
va nous donner des informations sur la façon d’utiliser la texture. Pour des avantages de taille, il
se peut que la texture ait été compressé. Il faudra donc l’a décompresser. Le sampler nous
donnera les propriétés de l’échantillonneur de textures pour les modes de filtrage et
d’enveloppement.
Voici un objet sans texture et un objet avec la prise en charge des textures :

Page 15/32

22 août 2022

Figure 11 : Sans et avec prise en charge du material

Sur la figure 11, on peut voir à gauche un objet, ici un cristal, sans material et sans texture. A
droite, on a la version avec les textures et les materials.
On voit clairement une nette différence entre les deux objets. On peut aussi ajouter qu’une
émissive map texture est utilisée pour le cristal. Grâce à elle, on pourra l’utiliser dans Unreal
pour émettre plus de lumière à certains endroits plutôt que d’autres.
2.1.4

Le format binaire, le GLB

glTF fournit deux options de livraison qui peuvent être utilisées ensemble :
— glTF JSON pointe vers des données binaires externes (géométrie, images clés, skins), et
des images.
— glTF JSON embarque des données binaires encodées en base64, et des images en ligne en
utilisant des URIs de données.
Par conséquent, le chargement des fichiers glTF nécessite généralement soit des requêtes
séparées pour récupérer toutes les données binaires, soit un espace supplémentaire dû au codage
base64. Le codage base64 nécessite un traitement supplémentaire pour le décodage et augmente
la taille du fichier (d’environ 33% pour les ressources codées). Si le gzip de la couche de
transport atténue l’augmentation de la taille du fichier, la décompression et le décodage
ajoutent encore un temps de chargement important.
Pour éviter cette taille de fichier et ce surcoût de traitement, un format de conteneur, Binary
glTF aussi appelé GLB, est introduit pour permettre à une ressource glTF, y compris JSON, les
tampons et les images, d’être stockée dans un seul blob binaire.
Ainsi, GLB est la forme binaire de glTF incluant notamment les textures plutôt que de les
référencer en tant que fichiers externes. Cette version n’est pas lisible par l’humain. Le buffer est
entièrement en binaire encodé en base64 tandis que le reste est en JSON. Concernant les
textures ou autres fichiers, nous avons fait le choix pratique de tout mettre dans le même fichier.
Il y a plusieurs avantages à utiliser le format GLB. En effet, il permet de réduire le poids des
Page 16/32

22 août 2022

fichiers mais il est aussi beaucoup plus rapide à lire. Il n’y a pas eu de réel test pour comparer
les deux formats, mais je peux dire sans prendre de risque qu’il est 2 à 3 fois plus rapide que le
format glTF classique à l’exécution.
Pour lire les données, il faut donc pouvoir convertir du binaire vers du JSON. L’en-tête en haut
du fichier va nous permettre de faire cela. Grâce à elle, nous pouvons savoir si c’est un fichier
GLB ou glTF.
Le GLB a la structure suivante :
— Un préambule de 12 octets, appelé l’en-tête.
— Un ou plusieurs chunks (voir lexique5) qui contiennent du contenu JSON et des données
binaires. Le chunk contenant JSON peut faire référence à des ressources externes comme
d’habitude, et peut également faire référence à des ressources stockées dans d’autres
chunks.
Le GLB est little endian (voir lexique5). La figure ci-dessous montre un exemple d’un actif glTF
binaire.
En voici un schéma :

Figure 12 : Structure du GLB

Nous pouvons voir que le fichier commence avec un l’en-tête puis s’en suit les chunks JSON et
enfin les chunks binaire. L’en-tête se compose de 3 entrées de 4 octets : uint32 magic, uint32
version et uint32 length
— Le nombre magique doit être égal à 0x46546C67. Il s’agit d’une chaîne ASCII glTF et
peut être utilisé pour identifier les données comme glTF binaire.
— Le nombre version indique la version du format de conteneur glTF binaire. Cette
spécification définit la version 2.
— Le nombre length est la longueur totale du glTF binaire, y compris l’en-tête et tous les
chunks, en octets.
Ensuite, un chunk a la structure suivante : uint32 chunkLength, uint32 chunkType, ubyte[]
chunkData
— chunkLength est la longueur des chunkData, en octets.
— chunkType indique le type de chunk.
— chunkData est la charge binaire du chunk.
Remarque : Nous rentrerons pas trop dans les détails mais il existe encore quelques
spécifications et exceptions concernant ce format.
Page 17/32

22 août 2022

J’ai développer une solution pour comprendre ce format de donnée. Elle sera utiliser si on
détecte que le fichier n’est pas un fichier glTF mais bien un fichier GLB. Ainsi, concernant les
fichiers 3D on prends en charge du glTF et du GLB.
2.1.5

Extensions du glTF

Les extensions glTF sont un gros point fort et l’un des principaux arguments utilisé par Quentin
pour choisir ce format de donnée. En effet, dans chaque section et sous section, il y a toujours
un champ extension permettant de créer notre structure personnalisée. Cela nous permettra
notamment de rajouter des données qui ne sont pas incluses par défaut dans le glTF.
La première extension que j’ai faite a porté sur les contraintes d’objet. J’ai créé une structure
personnalisée pour mettre une ou plusieurs contraintes à l’objet. Les contraintes portent sur la
location, la rotation, la taille mais ça va aussi plus loin. C’est ainsi qu’un objet peut décider de
copier les mouvements d’un autre ou bien seulement imiter sa rotation. Il peut aussi rester
seulement à une certaine distance d’un objet défini, etc... Comme on peut le voir, ça nous donne
pas mal de liberté pour contraindre notre objet.
Pour illuster, on peut voir sur la figure 13 ci-dessous une contrainte de rotation :

Figure 13 : Contrainte de rotation entre deux objets

Le cristal a gauche est contraint de suivre la rotation du cube de droite.
Toutes les informations sur les contraintes sont dans le fichier glTF avec notre structure
personnalisée. Il a fallu parser cette structure pour récupérer les données des contraintes et
pouvoir les appliquer à notre objet. J’ai aussi développé les différents comportements des
contraintes à utiliser en temps réels.
Une autre partie de développement pour les extensions glTF s’est portée sur les boîtes de
collision. En effet, on aimerait intégrer directement à l’objet des boites de collisions
fonctionnelles directement au chargement de l’objet. Ces boites auront diverses utilités comme
le fait d’empêcher l’utilisateur certaines actions.

Page 18/32

22 août 2022

2.2

Menu : Vue.JS avec vuetify

Une fois l’importateur glTF opérationnel, il a fallu afficher les différents objets et pour cela il
nous faut un menu. L’idée de Quentin pour la confection des menus est d’utiliser la puissance et
le design du web pour les fabriquer. Les menus seront fait avec Vue.js et son framework pour
pouvoir travailler au mieux en équipe en suivant une certaine architecture.
2.2.1

Utiliser une technologie web dans Unreal

Mais pour se faire, il faut pouvoir utiliser du web en temps réel dans notre environnement de
moteur de jeu. Quentin a récupérer et modifier un widget web browser pour faire tourner du web.
Ce widget comporte le noyau de Chromium. Chromium est un navigateur web libre développé
par l’organisation Chromium Project créée par Google en 2008. Chromium sert de base à
plusieurs autres navigateurs, dont certains open-source ou certains propriétaires. Grâce à ce
noyau, nous utilisons ce widget comme d’un navigateur classique et donc afficher des pages web.
Les menus serviront pour l’interaction des utilisateurs. Plusieurs menus vont être développé à
chaque fois à la suite d’un travail. Chaque menu fera le lien entre le client et le serveur VIRTFac
API. Le serveur API est relié à une base de donnée contenant les objets, les scènes, d’autres
informations...
Chaque menu sera géré par le WebMenuMangager, tous les menus sont rattachés à lui :

Figure 14 : Sans icône et avec un menu iconifié

A gauche, le web menu manager sans menu iconifié. A droite, j’ai iconifié le gestionnaire des
objets. On a donc une petite carte affichant en haut une icône et en bas le nom du menu. Si on
clique dessus, elle disparaîtra pour faire apparaître le menu à son dernier état.
Concernant les menus classiques, plusieurs options apparaîtront à droite de chaque menu de
façon verticale pour effectuer différentes actions :

Figure 15 : Les options des menus à l’horizontale

Voici les différentes fonctionnalités rattachées à nos boutons :
— Le premier bouton servira à déplacer le menu, ce qui est très utile.
— Le deuxième bouton permet d’agrandir le menu afin de mieux voir. Si le menu est déjà a
grandi, alors il va réduire le menu pour retrouver sa taille initiale.
Page 19/32

22 août 2022

— Le troisième bouton permet de recharger la page web. Cela peut régler certaines rares
problèmes d’affichages.
— Le dernier bouton sert à iconifier le menu. Le menu va disparaître et il sera dans une barre
de raccourci horizontale qui suit le joueur. Grâce à cette barre, on peut à tout moment
afficher à nouveau le menu iconifié.

2.3

Gestionnaire des objets

Voici un exemple de placement d’objets dans une scène :

Figure 16 : Placement d’objets dans une scène

Ce menu sert pour l’apparition des objets. On a une liste des différents objets disponible sur le
serveur. Ces objets sont stockés sur le serveur VIRTFac API géré par Quentin. Cela permet de
ne pas surcharger le client. Il suffit de rechercher un objet souhaité et de cliquer dessus pour le
récupérer. On vient ensuite le placer à un endroit choisi via un laser attaché à notre main.
La façon dont se déroule le processus est la suivante :
1. L’utilisateur va venir cliquer sur l’objet choisi
2. Le client Unreal va communiquer avec le serveur VIRTFac API pour demander l’objet
3. On attends la réception du message
4. Une fois la réponse arrivée, on vient lire la structure du message qui comporte différentes
informations comme : L’id, le nom, le gltf, la dernière date de modification, etc...
5. On récupère le gltf et on l’envoie notre l’importateur glTF en temps réel
6. Notre importateur nous renvoie le procedural mesh créé
Voici un aperçu du gestionnaire d’objet dans l’application en réalité virtuelle :

Page 20/32

22 août 2022

Figure 17 : Menu gestionnaire d’objet

— A gauche, on peut voir quelques boutons pour gérer les tags et trier les objets par
catégorie.
— Au centre, on a les différents objets affichés avec leur image correspondante ou un cube s’il
n’y a pas d’image.
— En bas, un bouton load asset pour charger un objet depuis un fichier JSON et des boutons
moins et plus pour gérer la taille des cartes des objets.
2.3.1

La structure

La structure du message json ressemble à ceci : Tout d’abord, on y retrouve des données
générales telles que le nom de l’objet, son ID, sa date de dernière modification, etc... Ensuite, ce
qui nous intéresse c’est le gltf qui est embarqué dans le champ data. On va l’extraire pour
importer l’objet 3D dans Unreal à l’aide de notre précédent importateur 3D gtTF.

2.4

Gestionnaire de scène

Après avoir placer les différents objets dans notre scène. On aimerait pouvoir l’enregistrer et l’a
charger plus tard en temps réel. Il faut donc créer un système pour sauvegarder tous les objets
avec leur position, rotation et taille et autres informations pertinentes pour reconstituer la scène.
Voici un aperçu du gestionnaire de scène dans l’application en réalité virtuelle :

Page 21/32

22 août 2022

Figure 18 : Menu gestionnaire de scène

Tout d’abord, on peut voir au centre une carte qui représente une scène.
Chaque carte a le nom de la scène et diverses informations générales sur celle-ci. On peut voir
une icône en haut à droite de la carte, elle permet de modifier les données générales de la scène.
On a aussi 4 icônes en bas de la carte, ce sont des boutons.
— Le premier sert à télécharger la scène au format JSON.
— Le deuxième bouton sert uniquement en dehors d’Unreal pour afficher la scène.
— Le troisième bouton permet d’afficher l’ensemble des informations de la scène.
— Le dernier bouton permet de supprimer la scène.
Enfin, l’ensemble de la carte est un bouton pour charger directement la scène.
Ensuite, en bas du menu, nous avons quatre boutons jaunes.
— Create new empty scene permet de créer une scène vide.
— Load scene permet de charger une scène à partir d’un fichier JSON fourni.
— Add object in scene permet de rajouter façon manuellement les objets (DEPRECATED)
Ce bouton n’est plus vraiment utile ainsi que le select en dessous. Maintenant, la scène
sauvegarde automatiquement toutes les 10 secondes tous les objets trouvés dans la scène.
— Save current scene permet de sauvegarder à la main l’entièreté de la scène.
2.4.1

La structure

Le gestionnaire de scène est une des fonctionnalités de la partie Ergonomio. J’ai dû trouver la
meilleure structure a utilisé pour les scènes. En effet, la structure ne contient pas directement
les objets mais seulement des références vers eux. Cela évite du poids inutile. Ces scènes seront
Page 22/32

22 août 2022

enregistrées en format JSON et répertoriées sur le serveur VIRTFac API. Les références seront
les id des objets sur le serveur.
Pour cela, j’ai créé une structure JSON que voici :

Figure 19 : Exemple de structure JSON scène

On peut voir dans le premier champ "scene" en haut quelques informations générales sur la
scène. Par exemple, on y retrouve le nombre d’asset, l’id de la scène sur le serveur API ou
encore le point de départ quand le personnage apparaît.
Ensuite, il y a la liste des différents assets que contient la scène. Chaque asset a des paramètres
comme son nom, son id ou encore sa position dans la scène. Il a aussi le champ profil qui va lui
spécifier si nécessaire son état pour chaque évènement.
Comme on peut voir, différentes informations sont retenus pour reconstruire la scène. On peut
voir tout d’abord les références des objets ainsi que leur position, rotations et tailles. Il y a aussi
des informations générales sur la scène comme son nom ou le nombre d’objets qu’elle contient.

Page 23/32

22 août 2022

2.5

Serveur VIRTFac Real Time

VIRTFac Real Time est un module utilisé pour manager des sessions collaboratrices. Il sera
particulièrement utile pour Ergonomio. Grâce à lui, on pourra :
— Créer, rejoindre ou quitter des salles
— Jouer des profils opc ua avec leurs évènements
Voici un schéma des différentes communications entre les différents clients et serveurs :

Figure 20 : Les différentes échanges entre client et serveur

Comme on peut le voir, le serveur VIRTFac Real Time communique avec Virtual reality qui est
l’application Unreal. Toutes la communications des salles, des partages de positions, des scènes
et des avatars passent par là. Ensuite, le serveur communique aussi avec le serveur VIRTFac
API pour mettre à jour différentes données comme le nombre de joueur d’une salle. Le serveur
fait la liaison entre le serveur opc ua et l’application Unreal pour transiter toutes les données
opc ua. Nous reviendrons sur cette figure dans la partie opc ua.
Pour créer ce serveur, j’ai utilisé nodeJS pour faire la communication entre plusieurs instances
d’Unreal. J’ai aussi utilisé express pour simplifier les routes. Ainsi le dossier public que j’utilise
est considéré comme la racine du projet. J’utilise aussi le module body-parser en tant que
middleware entre mon serveur et le client pour toutes les transactions. Toutes les messages sont
en JSON, ce qui permet une meilleure manipulation et clarté des données. Enfin, je me sers du
module socket.io pour le protocole de communication entre les messages. Cela me permet
d’utiliser les Web Sockets (voir lexique5) pour communiquer. Ce sont des connections
bi-directionnelles entre clients et serveur qui permettent une communication en temps réel sur
un autre protocole http normalement utilisé dans les pages web.
2.5.1

Système de socket

Quand un client se connecte, on lui attribue automatiquement un id pour l’identifier. Cet id sera
enregistré dans un dictionnaire pour garder une trace du client. Une fois connecté, le client peut
interagir avec les différentes routes comme demander de créer une salle ou rejoindre une salle.
2.5.2

Créer, rejoindre et quitter des salles

Comme dit dans le nom, on veut des sessions collaboratives. Par exemple, si on veut faire une
formation a une personne, il faut qu’elle puisse être suivi lors de l’entraînement. Avec une
session collaborative, il pourrait ainsi il y avoir un formateur qui supervisera la formation. On

Page 24/32

22 août 2022

aimerait avoir une salle reliée à une scène avec la possibilité d’avoir plusieurs personne à
l’intérieur et qu’on puisse voir ces personnes.
La première fonctionnalité c’est de pouvoir créer une salle reliée à une room. Lors de la création,
on rejoint automatiquement la salle indiquée. Ensuite, toutes les personnes peuvent voir la salle
grâce au lobby et l’a rejoindre potentiellement. On peut aussi envoyer le code de la salle pour la
rejoindre directement
Ensuite, quand on rejoint une personne, il faut pouvoir la voir. Chaque client va donc partager
toutes les données de son avatar comme la position, la rotation ou encore la taille de celui-ci.
Ces données seront partagées en temps réel et 60 fois par seconde. A chaque fois que le serveur
reçoit des données d’un client, il va les partager à tous les autres clients de la salle.
Enfin, on peut aussi quitter une salle. Cela nous renvoie dans le lobby principal, nous ne voyons
plus les autres joueurs et non ne partageons plus nos données de notre avatar
Mais le serveur VIRTFac Real Time ne sert pas qu’à ça. Il prends aussi en charge la distribution
des données opc ua.

2.6

OPC UA

Le protocole OPC-UA est un standard d’échange d’informations et de services, indépendant et
sécurisé. Il est particulièrement dédié à l’Internet Industriel des Objets (IoT).
Concernant OPC UA sur la figure 20, nous pouvons voir deux boites à gauche de Middleware
Client. C’est les deux types de données que nous prenons en compte pour la suite. En effet, soit
on choisit le classique OPC UA avec la ligne de production grâce aux capteurs qui nous envoie
les données. Soit, on prends un fichier en charge Witness. Dans les deux cas, le même formatage
sera fait concernant les données.
2.6.1

Serveur opc ua

Ce serveur a pour but de simuler le protocole opc ua en envoyant des données avec ce même
protocole. Au démarrage, il lit un fichier de configuration qu’il lui indiquera quel type de donnée
nous voulons qu’il génère. Le fichier lui indique aussi une salle vers laquelle il enverra les
différentes informations. La façon de comment marche le protocole OPC UA est la suivante :
chaque client doit s’abonner à une donnée pour recevoir sa valeur à chaque changement. C’est
exactement pareil avec des capteurs physique, à chaque fois qu’il y a une modification, ils
envoient un signal.
2.6.2

Client opc ua

Le but du client opc ua est de s’abonner aux différentes données qu’il l’intéresse et d’attendre
ces données. Ensuite, à chaque fois qu’il reçoit des données il les envoie au serveur VIRTFac Real
Time. En effet, il est à la fois client au serveur opc ua et client au serveur VIRTFac Real Time.
Ensuite le serveur VIRTFac Real Time s’occupe d’envoyer les données dans la bonne salle.
Toutes les personnes dans la salle recevront les données.
2.6.3

Profils et évènements

On pourra voir les différents profils et évènements à travers ce menu :

Page 25/32

22 août 2022

Figure 21 : Le menu opc ua avec les profils et les évènements

Sur la figure 21, on peut voir beaucoup d’informations.
Tout d’abord, au milieu on a une liste de profils. Chaque profil contient une liste d’évènements
qui sont les différentes valeurs des objets dans la scène à un instant T. On peut dérouler chaque
profil pour voir la liste d’évènement lui appartenant. Cela permet aussi de sélectionner un profil
pour par exemple le supprimer
En effet, chaque évènement peut modifier les valeurs des objets de la scène comme par exemple
leur position ou leur rotation. Tous les profils sont ensuite enregistrés dans le fichier scene.
Chaque objet à son ensemble de statut correspondant à chaque évènement. Si on clique sur un
évènement, tous les objets prennent leur valeur correspondant à celui-ci.
Ensuite, on peut voir à droite de chaque évènement deux boutons :
— Le premier en partant de la gauche sert à modifier l’évènement en question. Pour cela, il
faut au préalable sélectionné un objet et lui mettre les valeurs que l’on veut. Une fois cela
fait, il suffit de cliquer sur le bouton pour écraser les valeurs de l’évènement et prendre les
valeurs courante de l’objet.
— Le deuxième bouton lui sert à supprimer l’évènement.
Voici une petite explication des boutons en bas du menu :
— Démarrer le profil permet comme son nom l’indique de jouer le profil avec les différents
évènements. Les objets vont commencer à bouger en fonction des différents évènements. Il
faut sélectionner le profil au préalable.
Page 26/32

22 août 2022

— Supprimer le profil permet de supprimer un profil, il faudra sélectionner le profil au
préalable.
— Attacher un objet permet d’attacher en tant qu’enfant un objet à un autre qui sera son
parent.
— Ajouter un évènement permet d’ajouter manuellement un évènement à un profil. Il faudra
sélectionner le profil au préalable.
— Assigner un profil à la scène permet d’assigner le profil à la scène courante. En effet, une
scène ne peut avoir qu’un unique profil d’évènements opc ua. Chaque salle est aussi reliée
à une unique scène. On choisi le profil et la scène et il suffit de cliquer sur le bouton pour
mettre à jour le fichier.

Page 27/32

22 août 2022

3
3.1

Autre évènements
L’inaugurarion de l’école-usine d’Haguenau

Figure 22 : Ombre numérique de l’école-usine d’Haguenau

Cet évènement a duré une journée entière, le but était de faire une démonstration de VIRFAC.
Nous sommes allé avec Aymeric, Quentin et Thierry pour la présentation à l’inauguration de
l’école-usine d’Haguenau. Il a fallu faire des diapos ainsi qu’une présentation du projet en moins
de 10 minutes.
C’était très intéressant car il y avait une dizaine de groupe de personne pour voir la présentation.
On avait des avis extérieurs positifs et c’était très enrichissant. Nous avions pris tout le matériel
nécessaire pour que la présentation se déroule au mieux : Casques, ordinateurs, serveurs, etc...
On a donc fait une démonstration de VIRTFac avec une version non finie mais qui montrait
l’essentiel. Avec cette exhibition, on s’est rendu compte des différents ajustements à faire pour
améliorer l’application. C’était donc un bon exercice qui s’est révélé utile de part l’exercice mais
aussi pour la suite du projet

3.2

La présentation pour Confere22 à Bâles

Cette présentation était vers la fin du projet. Nous avions une version bien meilleure que lors de
la présentation à Haguenau. L’évènement a duré deux jours entiers. Il y avait plus de 80
personnes parmi les personnes qui présentaient. Nous y sommes allé à deux avec Aymeric.
Le but ici était de faire un article scientifique puis de faire une présentation avec des
diapositives sur le projet de façon générale. C’était un très bon exercice sachant que personne ne
nous encadrait. A la fin, nous avons eu des retours très positifs sur notre exhibition avec pleins
de remarques constructives. C’était une très bonne expérience et je remercie encore Thierry de
nous avoir envoyer là-bas.

Page 28/32

22 août 2022

4

Conclusion

Durant ce stage de 6 mois, j’ai eu la chance de faire beaucoup de choses différentes. En effet, j’ai
pu travaillé seul sur des développements mais aussi à plusieurs notamment avec Aymeric et
Quentin. Travailler en équipe dans un environnement professionnel a apporté beaucoup de
valeurs à ce stage. La grande quantité de technologie utilisée ont permis d’améliorer mon
adaptation à toutes épreuves. Avec cela, j’ai un esprit beaucoup plus critique sur le déroulement
du projet et une vison plus globale. Je pouvais sans hésiter proposer des améliorations ou des
pistes pour la suite. L’entente dans l’équipe a été superbe et c’est cela aussi que je recherche
pour mon stage de fin d’étude.
J’ai pu spécialement participer à deux expériences inédites citées plus haut. Elles m’ont permis
d’entraîner ma présentation orale et elles ont été très enrichissantes. Présenter nos travaux à des
personnes qui ne sont pas forcément dans le domaine nous permet de mieux voir les différentes
choses qui plaisent et celles qui plaisent moins.
J’ai participé au projet de VIRTFac depuis le début de mon master. J’ai débuté avec le projet
TER où j’ai commencé à prendre en main Unreal pour faire un modélisateur 3D en temps réel
en utilisant COGN en équipe avec Victor Roeck. Ensuite, on a poursuivi en stage d’été pour la
conception de menus futuristes pendant 2 mois. Au premier semestre du master 2, j’ai pris mon
sujet de projet master pour étudier l’ERP Odoo et ses avantages pour VIRTFac. Enfin, je
continue cette collaboration pour mon stage de master de fin d’étude. Je travaille sur différents
développement pour le projet et notamment sur Ergonomio et VIRTFac Real Time.
Cela a été une superbe expérience durant ces 2 ans de travailler avec Thierry Blandet. Grâce à
lui, j’ai beaucoup appris et pu évoluer au mieux. C’est pourquoi je continue avec lui en CDD
pour 1 mois en septembre pour finaliser les travaux pour VIRTFac. En effet, le projet interreg
européen se termine fin septembre. De nombreuses parties du projet peuvent être étoffées et on
pourra donner une bonne finalité à ce projet d’envergure.

Page 29/32

22 août 2022

5

Lexique

little endian : De l’ordre des octets dans lequel l’octet de poids le plus faible est enregistré à
l’adresse mémoire la plus petite ou transmis premièrement, et l’octet de poids supérieur est
enregistré à l’adresse mémoire suivante ou transmis deuxièmement.
procedural mesh : Dans Unreal, un procedural mesh permet de créer un mesh de zéro. Un
mesh est un objet tridimensionnel constitué de sommets, d’arêtes et de faces organisés en
polygones sous forme de fil de fer dans une infographie tridimensionnelle.
Chunk : Fragment d’une structure de données comme un fichier multimédia, tel que PNG, IFF,
MP3 ou AVI.
ERP : Le terme ERP vient de l’anglais « Enterprise Ressource Planning ». ERP a été traduit
en français par l’acronyme PGI (Progiciel de Gestion Intégré) et se définit comme un groupe de
modules relié à une base de données unique.
L’ERP est un progiciel qui permet de gérer l’ensemble des processus opérationnels d’une
entreprise en intégrant plusieurs fonctions de gestion : solution de gestion des commandes,
solution de gestion des stocks, solution de gestion de la paie et de la comptabilité, solution de
gestion e-commerce, solution de gestion de commerce BtoB ouBtoC ... dans un système.
Autrement dit, l’ERP représente la « colonne vertébrale » d’une entreprise.
MES : Le MES est un logiciel de pilotage de production collectant les données de production
en temps réel grâce à l’analyse de la traçabilité, au contrôle qualité, au suivi de production, à
l’ordonnancement et à la maintenance préventive et curative. Il permet de placer l’entreprise au
coeur de la révolution numérique en l’inscrivant dans une démarche de productivité et de
réduction des coûts.
CAO : La conception assistée par ordinateur ou CAO comprend l’ensemble des logiciels et des
techniques de modélisation géométrique permettant de concevoir, de tester virtuellement – à
l’aide d’un ordinateur et des techniques de simulation numérique – et de réaliser des produits
manufacturés et les outils pour les fabriquer.
JSON : JavaScript Object Notation est un format de données textuelles dérivé de la notation
des objets du langage JavaScript. Il permet de représenter de l’information structurée comme le
permet XML par exemple.
API : Une API est un ensemble normalisé de classes, de méthodes, de fonctions et de
constantes qui sert de façade par laquelle un logiciel offre des services à d’autres logiciels. Elle
est offerte par une bibliothèque logicielle ou un service web, le plus souvent accompagnée d’une
description qui spécifie comment des programmes consommateurs peuvent se servir des
fonctionnalités du programme fournisseur.
Jumeau numérique : Un jumeau numérique est une réplique numérique d’un objet, d’un
processus ou d’un système qui peut être utilisé à diverses fins. Les jumeaux numériques
intègrent l’intelligence artificielle, l’apprentissage automatique et l’analyse des données avec des
données pour créer des modèles de simulation numérique qui se mettent à jour et changent à
mesure que leurs contreparties physiques changent.
Socket : Apparu dans les systèmes UNIX, un socket est un élément logiciel qui est aujourd’hui
répandu dans la plupart des systèmes d’exploitation. Il s’agit d’une interface logicielle avec les
services du système d’exploitation, grâce à laquelle un développeur exploitera facilement et de
manière uniforme les services d’un protocole réseau.
Il lui sera ainsi par exemple aisé d’établir une session TCP, puis de recevoir et d’expédier des
données grâce à elle.
TMS : Le terme générique de trouble musculosquelettique (TMS) ou de "lésion attribuable au
travail répétitif" (LATR), regroupe de nombreuses pathologies des tissus mous : muscles,

Page 30/32

22 août 2022

tendons, nerfs. C’est la maladie professionnelle la plus courante dans les pays développés en
2012. Les facteurs de risque des TMS incluent les facteurs biomécaniques, les facteurs
psychosociaux (le stress), ainsi que les caractéristiques de l’individu.
Witness : Witness est un logiciel de simulation de processus qui permet de concevoir et
améliorer vos installations. Cet outil d’ingénierie sert à construire sur ordinateur des modèles
dynamiques de vos processus aussi complexes qu’ils soient.

Page 31/32

22 août 2022

Références
[1] Luc Jager et Victor Roeck. Stage d’été : Jarvis.
[2] Gltf documentation officielle. https://www.khronos.org/api/index_2017/gltf.
[3] B. Iung J. Chapelin, B. Rose. Intégration du jumeau numérique dans le cycle de vie d’un
projet industriel.
[4] L’institut national des sciences appliquées de strasbourg. https://www.insa-strasbourg.
fr/fr/.
[5] Grieves M. Digital twin : manufacturing excellence through virtual factory replication.
[6] Grieves M. Paper presented at the product lifecycle management special meeting.
[7] Protocole opc ua industriel. https://blog.integral-system.fr/protocole-opc-ua/.

[8] Présentation
et
page
officielle
du
projet
européen
virtfac
interreg.
https://www.interreg-rhin-sup.eu/projet/
v-i-r-t-fac-virtual-innovative-real-time-factory-optimiser-le-passage-a-lindustrie-4-0#:~:text=Fac(VirtualInnovativeRealTimeFactory)%3AOptimiserlepassage,
desactivitésdesescomposants.
[9] F. Marmier | I. Rasovska | L.Dubreuil | B. Rose. Industry 4.0 learning factory : a canvas
for specifications.
[10] Q. Misslin J. Grosjean T. Blandet B. Rose. Ergonom.io ou l’ergonomie pour l’usine du
futur, juillet 2021.
[11] Site officiel de nodejs. https://nodejs.org/en/.
[12] Site officiel de vuejs. https://vuejs.org/.
[13] Site officiel du framework vuetify. https://vuetifyjs.com/en/.
[14] Site officiel meta quest 2.
https://store.facebook.com/fr/fr/quest/products/
quest-2/?utm_source=www.oculus.com&utm_medium=oculusredirect.
[15] Site officiel unreal engine. ‘https://www.unrealengine.com/.
[16] Site équipe igg sur icube. https://igg.icube.unistra.fr/index.php/Accueil.
[17] HOCHSCHULE OFFENBURG ... UNIVERSITÉ DE STRASBOURG, INSTITUT NATIONAL DES SCIENCES APPLIQUÉES DE STRASBOURG. Projet virtfac, igg.
https://igg.icube.unistra.fr/index.php/VIRTFac.

Page 32/32

22 août 2022


Aperçu du document rapport_final_version_1_luc_jager.pdf - page 1/32

 
rapport_final_version_1_luc_jager.pdf - page 2/32
rapport_final_version_1_luc_jager.pdf - page 3/32
rapport_final_version_1_luc_jager.pdf - page 4/32
rapport_final_version_1_luc_jager.pdf - page 5/32
rapport_final_version_1_luc_jager.pdf - page 6/32
 




Télécharger le fichier (PDF)




Sur le même sujet..





Ce fichier a été mis en ligne par un utilisateur du site. Identifiant unique du document: 01986016.
⚠️  Signaler un contenu illicite
Pour plus d'informations sur notre politique de lutte contre la diffusion illicite de contenus protégés par droit d'auteur, consultez notre page dédiée.