Nous proposons une méthode pour placer automatiquement des sondes dans une scène par minimisation d’une fonction d’erreur. Nous guidons les sondes vers les sites d’échantillonnage optimaux en appliquant la descente de gradient à une fonction d’erreur qui représente la similarité entre la structure en construction et un ensemble de référence. En utilisant la pondération inverse à la distance comme fonction interpolante, nous avons construit avec fiabilité des ensembles de sondes dans trois scènes. En comparant nos résultats avec ceux produits par un ensemble de sondes de référence placées sur une grille régulière, nous atteignons théoriquement notre objectif dans une des trois scènes, où nous obtenons des valeurs d’erreur inférieures à la référence avec beaucoup moins de sondes. Nous avons eu des succès partiels dans les autres scènes, selon le nombre d’échantillons utilisés. / Diffuse global illumination within a 3D scene can be approximated in real time using irradiance probes. Probe placement typically relies on significant human input, and final quality of the approximation is often left to the subjectivity of a lighting artist. As demand for realism in rendering increases, the need to enhance the quality of such approximations is greater. We propose a method to automatically place probes in a scene by minimizing an error function. We guide probes to optimal sampling locations by applying gradient descent to an error function that represents similarity between our interpolated results and reference irradiance values. Using weighted nearest neighbour interpolation, we were able to reliably construct probe sets with minimal input in three scenes. Comparing our results to those produced by a set of probes placed on a 3D grid, we were theoretically successful in one scene, in which we could obtain lower error values with fewer probes. We obtained partial success in the other scenes, depending on the number of samples used.

Les études récentes sur les Interactions Homme-Machine ont intégré la dimension émotionnelle dans l'évaluation de l'expérience de l'utilisateur. En effet, un nouveau courant de recherche est apparu à savoir l'informatique affective, qui a donné lieu à une nouvelle génération de jeux vidéo capables d'interagir avec l'utilisateur en prenant en considération ses émotions, appelée jeux vidéo affectifs. L’objectif principal de ces jeux est de garder le joueur engagé durant la session du jeu. Pour y arriver, le jeu vidéo doit mesurer et réguler l‘état émotionnel du joueur en ajustant ses différents composants. Malgré le nombre important des recherches qui visent à améliorer le processus de détection émotionnelle, toutes les mesures utilisées jusqu'à présent ont montré certaines limites à cause de la complexité d'interprétation du concept émotionnel. Dans le présent travail, nous proposons de mesurer et soutenir l'engagement mental du joueur dans un environnent de jeu vidéo. Nous avons d’abord développé une première version de jeu vidéo et nous avons conduit une première étude expérimentale pour mesurer l'engagement mental du joueur à partir d'un index d’engagement mental extrait des données de l’activité cérébrale du joueur et plus précisément l’électroencéphalographie (EEG). Nous avons ensuite développé une deuxième version de jeu vidéo capable de capter l'état d'engagement mental (engagé, désengagé) du joueur et de déclencher un ensemble de stratégies d'engagement. Finalement, nous avons réalisé une deuxième étude expérimentale pour vérifier la capacité de ces stratégies à corriger l'état de manque d'engagement (désengagement) à augmenter et à maintenir le niveau d'engagement du joueur durant le jeu. Mots-clés : jeux vidéo, engagement mental, émotions, électroencéphalographie, stratégies d’engagement. / Recent studies in human-machine interactions have integrated the emotional dimension into the evaluation of the user’s experience. Indeed, a new current research has emerged, namely affective computing, which has given rise to a new generation of video games capable of interacting with the user taking into consideration his emotions, called affective video games. The main objective of the games is to keep the player engaged during the game session. To achieve this, the video game must measure and regulate the player’s emotional state by adjusting its different components accordingly. Although the large number of researches that aim to improve emotional detection processes, all the measures used up to now have shown some limitations, because of the complexity of the emotional concept interpretation. In this work, we add to these studies by formally proposing to measure and support the player’s mental engagement in a video game environment. First, we developed a first version of video game and we conducted a first experimental study to measure the player’s mental engagement from a mental engagement index extracted from the player’s brain activity data, and more precisely Electroencephalography (EEG). Second, we developed a second version of video game capable of capturing the player’s mental engagement state (engaged, disengaged) and triggering a set of engagement strategy. Finally, we carried out a second experimental study to verify the ability of these strategies to correct the engagement lack state (disengagement) and to increase and maintain the player engagement level during the game. Keywords: video games, mental engagement, emotions, electroencephalography, engagement strategy.

Ce mémoire décrit et évalue un système de module qui améliore la migration de code dans le langage de programmation distribuée Termite Scheme. Ce système de module a la possibilité d’être utilisé dans les applications qu’elles soient distribuées ou pas. Il a pour but de faciliter la conception des programmes dans une structure modulaire et faciliter la migration de code entre les nœuds d’un système distribué. Le système de module est conçu pour le système Gambit Scheme, un compilateur et interprète du langage Scheme utilisé pour implanter Termite. Le système Termite Scheme est utilisé pour implémenter les systèmes distribués. Le problème qui est résolu est la diffusion de code compilé entre les nœuds d’un système distribué quand le nœud destination n’a aucune connaissance préalable du code qu’il reçoit. Ce problème est difficile car les nœuds sont hétérogènes, ils ont différentes architectures (x86, ARM). Notre approche permet d’identifier les modules de façon unique dans un contexte dis- tribué. La facilité d’utilisation et la portabilité ont été des facteurs importants dans la conception du système de module. Le mémoire décrit la structure des modules, leur implémentation dans Gambit et leur application. Les qualités du système de module sont démontrées par des exemples et la performance est évaluée expérimentallement. / This thesis presents a module system for Termite Scheme that supports distributed computing. This module system facilitates application modularity and eases code migration between the nodes of a distributed system. This module system also works for developing non-distributed applications. The Gambit Scheme system is used to implement the distributed Termite and the Module system. The problem that is solved is the migration of compiled code between nodes of a distributed system when the receiving node has no prior knowledge of the code. This is a challenging problem because the nodes are not homogenous, they have different architectures (ARM, x86). Our approach uses a naming model for the modules that uniquely identifies them in a distributed context. Both ease of use and portability were important factors in the design of the module system. The thesis describes a module system and how it was integrated into Gambit. The system allows developing distributed modular systems. The features of this system are shown through application examples and the performance is evaluated experimentally.

La réutilisation est une pratique courante lors du développement de logiciel. Bien souvent, cette réutilisation se fait à travers l’utilisation des librairies. Cette dernière met ses fonctionnalités à disposition des développeurs en utilisant les Interfaces de Programmation d’Application (API). En théorie, les développeurs qui utilisent les API n’ont pas forcément besoin de se préoccuper de comment les éléments internes de cette API fonctionnent. En effet, les API mettent leurs fonctionnalités à disposition des développeurs sans forcément dévoiler ce qui se passe à l’interne. Cependant, pour utiliser correctement une API il est nécessaire de respecter des contraintes d’utilisation qui sont à la fois implicites et explicites ainsi que des modèles d’utilisation. L’usage des librairies et des API est très commun dans le domaine du développement de logiciel. Cela permet aux développeurs d’utiliser les fonctionnalités proposées par l’API et ainsi de se concentrer directement sur la tâche qu’ils doivent effectuer. Toutefois, apprendre et se familiariser avec les contraintes d’usage des API sont des tâches ardues et exigent un effort cognitif considérable de la part du développeur. Les chercheurs ont tenté de corriger ce problème en étudiant les modèles d’utilisation et en analysant les traces d’utilisation de code client pour s’assurer de leurs conformités. Néanmoins, les analyses dynamiques ne sont pas possibles pendant les phases précoces de développement du logiciel, car cela requiert une implémentation minimum et l’exécution du code. Nous proposons l’outil Temporal Usage PAttern Checker (Tupac). Une approche basée sur l’analyse statique interprocédural pour vérifier la conformité du code client aux modèles d’utilisation pendant la phase de développement. Tupac peut être déployé dans un envi- ronnement de développement (IDE) et ainsi fournir des informations relatives à l’utilisation des API plus tôt pendant la phase de développement du logiciel. Nous avons évalué notre approche sur quatre projets Java avec quatre API. Les résultats ont démontré que Tupac a une bonne précision et un taux de rappel intéressant. De plus, nous avons pu conclure qu’en moyenne cela prend une demi-seconde pour vérifier la confor- mité d’un patron pour un projet tout entier. Cela démontre que Tupac peut être déployé dans un rythme de codage régulier. / In modern software development, reuse takes the form of using libraries that expose their functionality via Application Programming Interfaces (APIs). In theory, APIs allow developers to write client code that reuses library code without needing to know its internals. In practice, correctly using APIs requires respecting explicit and implicit constraints and usage patterns. This allows developers to use functionality proposed by API so that they can focus directly on the task they want to achieve. APIs require a significant effort from the developer to learn various usage constraint. Ignoring such patterns could lead to errors and design flaws. These often cannot be detected prior to integration and system testing. Researchers have attempted to solve this problem by extracting API usage patterns and analyzing client code traces for conformance. However, dynamic analysis is still impossible to perform early without a minimum of integration and execution. We propose the Temporal Usage PAttern Checker (Tupac) for API, an interprocedural static analysis approach that can verify that client code conforms to temporal API usage patterns as it is being developed. Tupac can be deployed inside an Integrated Development Environment (IDE), thus providing developers with feedback about API usage much earlier in the development process. We evaluated the effectiveness of our approach on four projects with four different APIs. Our evaluation shows that Tupac has good precision and interesting recall. Crucially, we also show that it takes, on average, half a second to check an entire project for conformance to a pattern, meaning that it can realistically be deployed in the regular coding rhythm

Le contrôle de version est la pierre angulaire des processus de développement de logiciels modernes. Tout en construisant des logiciels de plus en plus complexes, les développeurs doivent comprendre des sous-systèmes de code source qui leur sont peu familier. Alors que la compréhension de la logique d'un code étranger est relativement simple, la compréhension de sa conception et de sa genèse est plus compliquée. Elle n'est souvent possible que par les descriptions des révisions et de la documentation du projet qui sont dispersées et peu fiables -- quand elles existent. Ainsi, les développeurs ont besoin d'une base de référence fiable et pertinente pour comprendre l'historique des projets logiciels. Dans cette thèse, nous faisons les premiers pas vers la compréhension des motifs de changement dans les historiques de révision. Nous étudions les changements prenant place dans les métriques logicielles durant l'évolution d'un projet. Au travers de multiples études exploratoires, nous réalisons des expériences quantitatives et qualitatives sur plusieurs jeux de données extraits à partir d'un ensemble de 13 projets. Nous extrayons les changements dans les métriques logicielles de chaque commit et construisons un jeu de donnée annoté manuellement comme vérité de base. Nous avons identifié plusieurs catégories en analysant ces changements. Un motif en particulier nommé "compromis", dans lequel certaines métriques peuvent s'améliorer au détriment d'autres, s'est avéré être un indicateur prometteur de changements liés à la conception -- dans certains cas, il laisse également entrevoir une intention de conception consciente de la part des auteurs des changements. Pour démontrer les observations de nos études exploratoires, nous construisons un modèle général pour identifier l'application d'un ensemble bien connu de principes de conception dans de nouveaux projets. Nos résultats suggèrent que les fluctuations de métriques ont le potentiel d'être des indicateurs pertinents pour gagner des aperçus macroscopiques sur l'évolution de la conception dans l'historique de développement d'un projet. / Version control is the backbone of the modern software development workflow. While building more and more complex systems, developers have to understand unfamiliar subsystems of source code. Understanding the logic of unfamiliar code is relatively straightforward. However, understanding its design and its genesis is often only possible through scattered and unreliable commit messages and project documentation -- when they exist. Thus, developers need a reliable and relevant baseline to understand the history of software projects. In this thesis, we take the first steps towards understanding change patterns in commit histories. We study the changes in software metrics through the evolution of projects. Through multiple exploratory studies, we conduct quantitative and qualitative experiments on several datasets extracted from a pool of 13 projects. We mine the changes in software metrics for each commit of the respective projects and manually build oracles to represent ground truth. We identified several categories by analyzing these changes. One pattern, in particular, dubbed "tradeoffs", where some metrics may improve at the expense of others, proved to be a promising indicator of design-related changes -- in some cases, also hinting at a conscious design intent from the authors of the changes. Demonstrating the findings of our exploratory studies, we build a general model to identify the application of a well-known set of design principles in new projects. Our overall results suggest that metric fluctuations have the potential to be relevant indicators for valuable macroscopic insights about the design evolution in a project's development history.

No description available.

No description available.

No description available.

Le génie logiciel a pour but de créer des outils logiciels qui permettent de résoudre des problèmes particuliers d’une façon facile et efficace. À cet égard, l’ingénierie dirigée par les modèles (IDM), facilite la création d’outils logiciels, en modélisant et transformant systématiquement des modèles. À cette fin, l’IDM s’appuie sur des workbenches de langage : des environnements de développement intégré (IDE) pour modéliser des langages, concevoir des modèles, les exécuter et les vérifier. Mais l’utilisation des outils est loin d’être efficace. Les activités de l’IDM typiques, telles que la création d’un langage de domaine dédié ou créer une transformation de modèles, sont des activités complexes qui exigent des opérations souvent répétitives. Par conséquent, le temps de développement augmentate inutilement. Le but de ce mémoire est de proposer une approche qui augmente la productivité des modélisateurs dans leurs activités quotidiennes en automatisant le plus possible les tâches à faire dans les outils IDM. Je propose une solution utilisant l’IDM où l’utilisateur définit un flux de travail qui peut être paramétré lors de l’exécution. Cette solution est implémentée dans un IDE pour la modélisation graphique. À l’aide de deux évaluations empiriques, je montre que la productivité des utilisateurs est augmentée et amééliorée. / Software engineering aims to create software tools that allow people to solve particular problems in an easy and efficient way. In this regard, Model-driven engineering (MDE) enables to generate software tools, by systematically modeling and transforming models. In order to do this, MDE relies on language workbenches: Integrated Development Environment (IDE) for engineering modeling languages, designing models executing them and verifying them. However, the usability of these tools is far from efficient. Common MDE activities, such as creating a domain-specific language or developing a model transformation, are nontrivial and often require repetitive tasks. This results in unnecessary risings of development time. The goal of this thesis is to increase the productivity of modelers in their daily activities by automating the tasks performed in current MDE tools. I propose an MDE-based solution where the user defines a reusable workflow that can be parameterized at run-time and executed. This solution is implemented in an IDE for graphical modeling. I also performed two empirical evaluations in which the users’ productivity is improved.

Ce mémoire porte sur la reconstruction 3D active par la lumière structurée et se veut une introduction au travers d'une vue d'ensemble du domaine. L'accent est mis sur une compréhension des différents aspects du scan 3D, en commençant par l'acquisition du matériel et en allant jusqu'au calcul d'un modèle 3D. Les défis techniques les plus fréquents dans un contexte de scan 3D avec de l'équipement à faible coût sont abordés, de façon à donner une idée générale des problèmes à anticiper à quelqu'un qui souhaiterait se lancer dans la conception ou l'utilisation de ce type de scanneur. Afin d'aider à peser les forces et faiblesses de chaque algorithme formant l'état de l'art actuel en lumière structurée, une revue des différentes stratégies existantes est également donnée. L'étude du domaine a mené à une contribution sous la forme d'un article, qui a été intégré dans le chapitre 6. Cet article propose une amélioration en ce qui concerne la performance et la précision d'un algorithme de scan 3D existant et a été publié dans la International Virtual Conference on 3D Vision en novembre 2020. / This thesis focuses on active 3D reconstruction with structured light and is intended to be an introduction through an overview of the field. It is focused on understanding the different aspects of a 3D scanner, from the acquisition of the material to the final mesh reconstruction. The most common technical difficulties that arise in the context of low-cost 3D scanning are addressed, to give a general idea of the potential technical problems that may occur when using a DIY 3D scanner built from scratch. To help assess the strengths and weaknesses of each algorithm of the current state of the art in structured light, a review of the different strategies is also proposed. The study of this domain led to the contribution of a paper, presented here in its entirety in chapter 6. This paper describes an improvement of an existing algorithm, both in terms of performance and precision, and was published in the International Virtual Conference on 3D Vision in November 2020.