Newer
Older
## Application industrielle concrète
Vous êtes développeur dans une société de service et le CNES (centre national des études spatiales) demandent à votre société de lui proposer de faire une étude technique afin d'optimiser leur programme d'analyse d'images satellitales. Il vous demande de faire une étude comparative de solutions comme Python et C++ pour paralléliser leurs calculs. Ils ont des experts en imagerie spatiale mais pas de développeur avec les compétences requises. Il vous demande aussi de proposer des solutions plus innovantes comme le GPU Computing (Cuda, OpenCL, etc...). Il souhaiterait avoir un prototype afin de pouvoir prendre des décisions en fonction des comparaisons des performances, limitations (taille mémoire, etc...), contraintes logicielles, portabilité (Linux, Windows, ...), etc...
## BUT
Développer un outil de traitement d'images en utilisant les concepts vu en cours, en comparant les approches séquentielles et parallèles. Utilisez des algorithmes permettant de tester le côté parallèle (conversion d'espace de couleurs ? filtrage (flou), détection de contours?, ...). Faire des timings et une interface graphique de base pour changer dynamiquement les paramètres et configuration (nombre de threads, etc...).
C'est un projet que vous pourrez continuer par la suite (ajout de réseaux, etc...) ou le montrer pour chercher des stages, etc...
NOTE : Les 5 fichiers "imgui_impl_glfw.h", "imgui_impl_opengl3.h", "imgui_impl_opengl3_loader.h", "imgui_impl_glfw.cpp" et "imgui_impl_opengl3.cpp" sont fournis par ImGui. J'ai juste fait une modification pour qu'il utilise mon loader de librairie OpenGL, GLAD, afin de pouvoir utilisé un OpenGL plus récent.
Piur ceux qui veulent comparer les temps CPU et GPU, OpenGL fournit un objet pour calculer le temps des actions passées sur GPU :
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
```
// START of program : INITIALIZATION
// Device timer(s) [GPU]
GLuint64 mGPUTime = 0;
GLuint mGPUQueryTimeElapsed;
glCreateQueries( GL_TIME_ELAPSED, 1, &mGPUQueryTimeElapsed );
// ...
// RENDERING LOOP
// Timer: start
glBeginQuery( GL_TIME_ELAPSED, mGPUQueryTimeElapsed );
// GPU kernel
glUseProgram( shaderProgram );
// ...
glDispatchCompute( gridSizeX, gridSizeY, 1 );
// Timer: end
glEndQuery( GL_TIME_ELAPSED );
glGetQueryObjectui64v( mGPUQueryTimeElapsed, GL_QUERY_RESULT, &mGPUTime );
// Display timing
ImGui::Text( "Timing: %f ms", static_cast< float >( mGPUTime * 1.e-6 ) );
// ...
// END of program : CLEANING
// - device timers
glDeleteQueries( 1, &mGPUQueryTimeElapsed );
```
Idée : chargement d'images asynchrone.
Pendant la boucle de rendu, demander à un thread d'aller ouvrir et charger une image sans bloquer la boucle de rendu. Tant que le thread n'a pas fini, on interroge s'il a fini et uniquement là, on demande à OpenGL d'updater/créer la texture en envoyant les données du CPU vers la mémoire GPU.
C'est ce qu'on fait dans les applications de type GoogleEarth pour charger des bouts de terrain et textures associées (la terre est découpée en tuiles qu'on charge à la demande lorsqu'elles sont visibles depuis la caméra => requêtes web asynchrones sur des serveurs).
Il me semble que ça peut se faire avec l'objet C++ "condition" (comme en Python), ou peut-être plus simplement ?
Exemple : schéma de l'idée (il faut aller voir la doc et un example de "condition" en C++) :
```while ()
{
Button::Apply("Load Image")
{
threadImage.load( "xxx.jpg" ); // from file or internet : we would liki to block the rendering loop as few as possible
// => while retrieving data and loading, the rendering loop can continue without blocking from several frames, several secondes, etc...
// à la fin, le thread met à jour la variable isNewImageIsLoaded à true.
if ( isNewImageIsLoaded )
{
// create/update OpenGL texture
...
isNewImageIsLoaded = false;
}
}
Il existe aussi les tasks en C++ avec les objets "std::async" et le couple "promise"/"future".