RAPPORT DE STAGE DE FIN D’ÉTUDES - Centrale Marseille · 2015-12-13 · RAPPORT DE STAGE DE FIN...

RAPPORT DE STAGE DE F IN D ’ÉTUDES

Étude des mécanismes de spécialisation neuronale lors d’une tâche RSVP

Stage r7alisé du 13 avril au 30 septembre 2015 au Centre de Recherche Cerveau et Cognit ion

Camille BREUIL Promo 2015

Tuteurs: Simon Thorpe (Centre de Recherche Cerveau et Cognition) et Mireil le Commandré ( cole Centrale Marseille)

REMERCIEMENTS

Je tiens remercier: - Simon Thorpe, directeur du Centre de Recherche Cerveau et Cognition, investigateur principal du projet M4 et encadrant de mon TFE pour m'avoir permis de faire ce stage - Nad ge Mac7 et Karine Bouyer, managers du projet M4, pour leur accompagnement - Evelina Thunell, post-doctorante, pour sa relecture de ce rapport et ses conseils avis7s - Sophie Muratot, assistante la recherche, pour son aide pr7cieuse lors du recrutement de participants pour l'exp7rience - Christelle Larzabal, Jaya Viswanathan, Julien Clauzel, Jake Martin et Evelyne Lepron, doctorants et post-doctorants de l'7quipe pour leurs retours sur mon travail et sur l'application - Maxime Rosito, ing7nieur en d7veloppement, pour son assistance technique - Tous les membres du projet M4 et de l'7quipe PROS pour leur accueil Camille'breuil'

1

RÉSUMÉ J'ai effectu7 mon projet de fin d'7tudes au Centre de Recherche Cerveau et Cognition, au sein de l'7quipe PROS. Mon stage s'est inscrit dans un projet plus vaste, le projet "M4: Memory Mechanisms in Man and Machine" dont l'objectif est de mieux appr7hender le fonctionnement de la m7moire. cette fin, une 7quipe largement pluridisciplinaire s'attache tester 10 hypoth ses provocatrices sur ce sujet. La mission qui m'a 7t7 confi7e pendant mon stage consistait d7velopper un nouveau paradigme exp7rimental dans le but d'7tudier les m7canismes de sp7cialisation neuronale dans des t ches d'apprentissage visuel. Je me suis dans un premier temps attach7e la conception du paradigme, puis j'ai d7velopp7 celui-ci sous forme d'une application, de fa on ce que la t che exp7rimentale puisse tre r7alis7e sur tablettes. J'ai ensuite analys7 les r7sultats pr7liminaires obtenus dans le cadre de cette exp7rience et effectu7 un certain nombre de modifications sur l'application.

SUMMARY I did my intership at the Centre de Recherche cerveau et Cognition, within the team PROS. My internship joined in a vaster project, "M4: Memory Mechanisms in Man and Machine" which aims to understand memory mechanisms. Ten provocative and controversial claims about human sensory memories will be tested with a highly interdisiplinary approach. The aim of my internship was to develop a new experimental paradigm to study neural specialization for visual stimuli. I began by creating the new paradigm, then I developped an application to make it possible for people to participate in the experiment using a digital tablet. Next, I analysed firt results of the experiment and improved the application. 2

SOMMAIRE

3

REMERCIEMENTS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1 RÉSUMÉ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2 SOMMAIRE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3 INTRODUCTION. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5 CONTEXTE ET ENJEU. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .6

Le con tex te du pro je t . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Le Centre de Recherche Cerveau et Cognit ion (CerCo). . . . . . . . .6 L’équipe PROS.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .6 Le projet M4.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7

Les hypothèse provocatrices...............................................................7 Le déroulement du projet.....................................................................8 État de l'art et objectifs scientifiques du projet..................................9

Les neurones "grand-mère".........................................9

Spike-Time Dependent Plasticity (STDP)........................ .10

L'apprentissage....................... .. .... .. ... .. ... .. ... .. ... .. ... .. ....11

Ma miss ion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

DÉVELOPPEMENT DU PARADIGME. . . . . . . . . . . . . . . . . . . . . . . . .14

Concept ion du parad igme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 Le système visuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 Le protocole RSVP (Rapid Serial Visual Presentation). . . . . . . .16 Le paradigme proposé.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .17 L'expérimentation innovante.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .19

Déve loppement de l 'app l ica t ion . . . . . . . . . . . . . . . . . . . . . . . . . . 23 Environnement de développement.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23 Cahier des charges.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23

Fonctionnalités.......................................................................23 Contraintes scientifiques.....................................................24 Ergonomie/interface utilisateur............................................24

Gestion des images...........................................................................25 Paramètrage de la tâche...................................................................26 Enregistrement et transmission des données...................................26 Contrôle sur la fiabilité des données.................................................27 Aspect ludique et ergonomique........................................................28

Val ida t ion e t d is t r ibu t ion . . . . . . . . . . . . . . . . . . . . . . . . . . . . .28

RÉSULTATS PRÉLIMINAIRES. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30 Matér ie l e t méthode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30 Ana lyse des résu l ta ts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .31

Effet de l 'âge, du genre et de l 'appareil . . . . . . . . . . . . . . . . . . . . . . . . . . . . .32 Effet de l'âge.....................................................................................32 Effet du genre....................................................................................33 Effet de l'appareil...............................................................................34

Effet d'apprentissage.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .34 Effet de la fréquence de défi lement des images.. . . . . . . . . . . . . . .35 Effet du nombre de présentations.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .36 Effet des images.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .39

Effet de la catégorie d'image....................................................39 Effet des caractéristiques des images...............................................40

Autres remarques.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .41 Retour des sujets/stratégie/attention.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .42

AMÉLIORATION DE L 'APPLICATION. . . . . . . . . . . . . . . . . . . . . . .43 Changements hors de la tâche . . . . . . . . . . . . . . . . . . . . .43 Chengements de la tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43

Simplif ication de la tâche.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43 Le rôle des oscil lations.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .44

BILAN ET PERSPECTIVES. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .46 B IBLIOGRAPHIE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47

4

Le développement de l 'application.. . . . . . . . . . . . . . . . . . . . . . . . . . .25

ANNEXES. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .50

INTRODUCTION J'ai choisi d'effectuer mon stage de fin d'études au Centre de Recherche Cerveau et Cognition. Cette expérience a été pour moi l'occasion de découvrir un peu mieux le domaine de la recherche et a constitué une transition instructive entre ma formation d'ingénieur généraliste et le début de mon doctorat en sciences cognitives. Ce rapport présente l'ensemble du travail que j'ai effectué durant mon stage. J'y expose les différentes étapes de la démarche que j'ai suivie dans l'objectif de contribuer à la compréhension des mécanismes de spécialisation neuronale et à l'élucidation du fonctionnement de la mémoire. Je présente dans un premier temps le contexte général du projet et la mission qui m'a été confiée. Je décris ensuite un à un les différents objectifs de ma mission ainsi que les problèmes auxquels j’ai été confrontée, les solutions apportées et les résultats obtenus. Enfin, je conclus ce rapport en discutant des perspectives entrouvertes pour la suite du projet.

5

CONTEXTE ET ENJEUX

Le contex te du pro je t Le Centre de Recherche Cerveau et Cognition (CerCo) Le Centre de Recherche Cerveau et Cognition (CerCo) est une unité mixte CNRS/Université Paul Sabatier (Toulouse 3) et l’une des unités de recherche de l’Institut des "Sciences du Cerveau de Toulouse". Les chercheurs du CerCo s’intéressent au fonctionnement des systèmes sensoriels comme la vision ou l’audition, ainsi qu’aux fonctions cognitives telles que la perception de l’espace, la reconnaissance d’objet, la mémoire, mais aussi la conscience et les états mentaux. A travers une large panoplie d’outils méthodologiques, ils étudient les mécanismes neuronaux sous-jacents qui permettent d’expliquer la remarquable capacité de notre cerveau à percevoir et interpréter les informations de notre environnement sensoriel.

Le CerCo rassemble plus de vingt chercheurs experts du système visuel, une trentaine de doctorants et post-doctorants et une équipe technique autour de 4 principaux thèmes de recherche :

Dynamique du traitement et interactions corticales (DyTIC2.0) Espace et contexte 3D (ECO-3D) Perception et reconnaissance des objets et des scènes (PROS) Construction des représentations et états mentaux (CREMe)

C’est au sein de l’équipe Perception et reconnaissance des objets et des scènes (PROS) que j’ai effectué mon stage de fin d’études.

L’équipe PROS L’équipe PROS étudie la reconnaissance et la représentation neurale des objets et des catégories d’objets. Ses travaux se démarquent d’une part par l’utilisation de stimuli biologiquement pertinents (notamment des photographies de scènes naturelles) d’autre part par le choix d’approches multiples (projets expérimentaux chez l’homme en psychophysique, en 7lectroenc7phalographie, en imagerie par r7sonnance magn7tique fonctionnelle, enregistrements intracrâniens, approches théoriques et modélisation) dans l’objectif de déterminer les mécanismes clés qui sous-tendent la remarquable efficacité des systèmes visuels biologiques, d’analyser comment l’apprentissage et l’expertise peuvent structurer nos représentations visuelles et les substrats neuronaux assurant leur mise 6

en mémoire, et de cerner les effets délétères du vieillissement sain et pathologique. Les recherches en modélisation et neurosciences computationnelles ont notamment permis le développement de SpikeNet Technologies, une start-up lancée en 1999 par trois chercheurs du Cerco spécialisées dans la commercialisation de logiciels de reconnaissance d’objet. Actuellement, et depuis 2012, la majorité de l’équipe est impliquée dans le projet de recherche M4 : "Memory Mechanisms in Man and Machine".

Le projet M4 Le projet M4 : "Memory Mechanisms in Man and Machine", à l’initiative de Simon Thorpe, a été distingué en 2012 lors de l’appel à proposition « Chercheurs confirmés » du Conseil Européen de la Recherche (ERC). Lancé en 2012, le projet durera 5 ans et consiste à tester 10 postulats provocateurs concernant la mémoire.

Les hypothèses provocatrices

1 - Les êtres humains peuvent reconnaître des stimuli visuels et auditifs qui n’ont pas été revus ou entendus depuis des décennies.

2- La reconnaissance après de très longs délais est possible sans jamais réactiver la trace mnésique dans l’intervalle.

3- Ces mémoires à très long terme nécessitent une phase de mémorisation initiale, au cours de laquelle la force de la mémoire augmente à peu près

linéairement avec le nombre de présentations.

4- Quelques dizaines de présentations peuvent être suffisantes pour former une mémoire qui peut durer toute une vie.

5- Une activité oscillatoire liée à l'attention peut aider la formation de ces traces mnésiques.

6- Le stockage des souvenirs à très long terme implique la création de cellules hautement sélectives «grand�mère» qui s'activent uniquement si le

stimulus original est présenté à nouveau.

7- Le néocortex contient un grand nombre de cellules totalement silencieuses (« La matière Noire Corticale ») qui constituent le lieu de stockage des mémoires à long terme.

8- Des cellules « grand-mère » peuvent être produites en utilisant de simples modèles de réseaux neuronaux impulsionnels avec Spike-Time Dependent Plasticity (STDP) et des

connexions inhibitrices compétitives latérales.

9- Cette sélectivité ne nécessite que des poids synaptiques binaires qui sont soit « on », soit « off », ce qui simplifie grandement le problème de maintien de la

mémoire sur de longues périodes. 10- Des systèmes artificiels basés sur des dispositifs de type « memristor » peuvent mettre en oeuvre les mêmes principes, permettant le développement de nouvelles

architectures de traitement puissantes qui pourraient remplacer les systèmes informatiques conventionnels. 7

L’approche choisie pour tester ces hypothèses est fortement pluridisciplinaire, impliquant tout aussi bien la psychologie, les neurosciences, la modélisation informatique et le développement de "hardware". De nouveaux paradigmes expérimentaux sont développés dans le but d’étudier la formation et la maintenance des souvenirs sensoriels à très long terme. Ils sont combinés avec les techniques d’imagerie, notamment l’imagerie IRM, l’enregistrement EEG, et l’enregistrement intracérébral chez des patients épileptiques. En parallèle, des simulations informatiques utilisant des réseaux de neurones impulsionnels équipés avec Spike-Time Dependent Plasticity (STDP) vont tenter d’expliquer les résultats expérimentaux, mais aussi de développer des systèmes matériels bio-inspirés qui peuvent reproduire la capacité d’apprentissage du cerveau à l’aide de nouvelles technologies à base de memristors.

L’équipe qui travaille à ce jour sur le projet rassemble autour de l’investigateur principal un manager de projet, trois doctorants, deux post-doctorants, un ingénieur, trois chercheurs CNRS, deux enseignants-chercheurs et un professeur du CHU de Toulouse. C’est au sein de cette équipe largement pluridisciplinaire et réunissant des acteurs aux compétences variées que j’ai été intégrée dans le cadre de mon stage.

Le déroulement du projet

La durée totale du projet est de 5 ans. On peut distinguer quatre parties différentes convergents toutes vers un même objectif: le développement de systèmes artificiels bio-inspirés capables de mémoriser des informations à long terme de la même façon que le cerveau humain.

Figure 1 - Représentation schématique des grandes parties du projet M4

Développement de

« memristors »

Reconnaissance de stimuli après

plusieurs années sans réactivation

Modélisation de réseaux de

neurones artificiels équipés avec STDP

Formation des mémoires

sensorielles à long terme (effet des paramètres de présentation)

Mémorisation des informations

sensorielles durant des décennies

8

La mission qui m’a été confiée durant mon stage s’intégrait à la partie concernant la formation des mémoires sensorielles à long terme. On peut, en effet, constater qu’en fonction des modalités de présentation d’un stimulus, celui-ci ne sera pas mémorisé de la même façon. Durant mon stage je me suis intéressée en particulier à l’influence du temps de présentation et du nombre de répétitions d’un stimulus sur son apprentissage.

État de l’art et objectifs scientifiques du projet Tout le monde a déjà fait l’expérience de reconnaitre quelque chose qui n’avait pas été vu ou entendu depuis plusieurs années. Ce peut être un ancien camarade de classe recroisé par hasard ou encore le générique d’une émission de radio que l’on écoutait des années auparavant et qui est exceptionnellement rediffusée. C’est ici que commence le projet M4. Il existe effectivement une mémoire à long terme capable de stocker des souvenirs durant des années sans qu’ils n’aient besoin d’être réactivés. Si de nombreuses études ont été faites sur la mémoire, à l’heure actuelle les mécanismes impliqués dans celle-ci, et notamment dans la mémoire à long terme, restent encore largement méconnus. Comprendre ces mécanismes constitue donc l’enjeu principal du projet. Les neurones « grand-mère » Simon Thorpe a fait il y a quelques années une suggestion assez radicale concernant le fonctionnement de la mémoire à long terme (Thorpe 2011). Il propose, en effet, que la capacité à reconnaitre des stimuli après un long délai serait liée à la formation de neurones fortement sélectifs, à tel point qu’ils ne seraient réactivés que lors de la présentation du stimulus d’origine. Cette théorie rejoint celle des neurones « grand-mère » (Bowers 2009; Gross 2002) qui constitue la version extrême de l’hypothèse de codage éparse, par opposition avec un codage distribué. Il existe, en effet, deux grandes hypothèses concernant la façon dont sont codées les informations pour être stockées en mémoire: - Codage distribué: Un percept donné est codé par l'activité d'un grand ensemble de neurones, dans lequel chaque neurone est sélectif à une caractéristique particulière. Dans ce cas, pour chaque objet, un grand nombre de neurones de la population vont participer à son codage mais aucun neurone ne sera sp7cifique cet objet. - Codage éparse: Dans ce cas, un même percept est codé par un nombre beaucoup plus restreint de neurones. Dans ce cadre, la majorité des neurones sont tr s sp7cifiques, c'est- -dire qu'ils ne r7pondent qu' certains objets. La version extrême étant l'hypothèse du neurone grand-mère (1 neurone = 1 concept). 9

Cette hypothèse concernant l’existence de neurones grand-mère est largement controversée au sein de la communauté scientifique, son principal point faible 7tant que de mani re absolue, chaque objet, individu, chose du monde qui nous entoure poss7deraient son r7seau de neurones grand-m re: le nombre de neurones dont il faudrait disposer serait alors inimaginable. Cependant, certaines études ont déjà démontré l’existence de neurones très sélectifs chez l’homme. On peut notamment citer les très impressionnantes études réalisé s par Quian Quiroga et al. en 2005 et 2007 sur des patients épileptiques chez qui ils ont pu mettre en évidence grâce à des enregistrements intracrâniens l’existence de neurones répondant sélectivement à des photos de l’actrice Jennifer Aniston ou encore de l’opéra de Sydney. Cependant les auteurs eux-mêmes restent septiques (Quiroga 2008) quand à l’existence de véritables neurones grand-mère. Spike-Time Dependent Plasticity (STDP) Le mécanisme clé sur lequel s’appuie cette hypothèse d’apprentissage des neurones individuels est la STDP (Spike-Time Dependent Plasticity, parfois traduit en fran ais par la plasticit7 fonction du temps d'occurrence des impulsions). Il s’agit d’un mécanisme d’apprentissage très simple, dérivé du modèle de plasticité de Hebb (Hebb 1949), guidant la modification des poids synaptiques des entrées d'un neurone. Selon la loi de Hebb, un neurone va renforcer le poids de ses entrées les plus stimulées. La STDP étend ce principe en y intégrant une dimension temporelle : si le spike (potentiel d'action) afférent arrive avant la génération du spike du neurone intégrateur, alors la connexion sera renforcée. l'inverse, si le spike afférent arrive après la génération, alors la connexion sera affaiblie. L'effet de renforcement ou d'affaiblissement des connexions est d'autant plus important que les spikes sont temporellement rapproch7s (voir figure 2). Ceci se base donc sur une règle simple : si un spike arrive juste avant la génération, alors il est largement impliqué dans celle-ci, s'il arrive après, alors il n'a pas été utile. Cette règle permet ainsi au neurone d'apprendre implicitement lesquels de ces neurones afférents sont les plus informatifs. 10

Le groupe au sein duquel j’ai effectué mon stage a largement travaillé sur l’étude de ce mécanisme et a notamment développé depuis quelques années un modèle de reconnaissance d'objets où l'information qui transite entre les neurones n’est pas contenue dans leur taux de décharge mais dans leur ordre d’arrivée. Masquelier et Thorpe ont également montré en 2007 que les neurones apprennent naturellement à devenir sélectifs aux « patterns » des décharges qu’ils reçoivent de façon répétée. Ils ont par exemple mis en évidence la capacité de neurones à devenir sélectifs àcertains traits du visage avec moins d’une centaine de présentations d’images simplement parce que ces traits étaient répétés fréquemment et sans que l’apprentissage ne soit supervisé. En 2008, ils ont également pu observer qu’un pattern aléatoire de 50ms concernant une petite population de neurones afférents pouvaient être détecté après seulement une petite dizaine de répétitions (Masquelier et al., 2008). Ces résultats ont des implications très importantes sur les th7ories concernant le fonctionnement de la m7moire. En effet, si la STDP est littéralement vraie, un neurone qui ne déchargerait jamais ne modifierait donc pas ses connections. Ceci signifie qu’un neurone qui apprendrait àrépondre spécifiquement à un stimulus donné pourrait potentiellement conserver ce pattern de connexion pour toujours. Si le stimulus n’est pas représenté, le neurone ne déchargera pas mais même après plusieurs années il sera capable de reconnaitre le stimulus initial. L’apprentissage

Nous avons pu voir précédemment que l’apprentissage basé sur la STDP pouvait être un moyen efficace de générer une sélectivité aux stimuli présentés de manière répétée. La question est maintenant de savoir si cet apprentissage automatique se manifeste effectivement chez l’homme. 11

Figure 2 - Spike-Time Dependent Plasticity: Présentation des poids des connections synaptiques en fonction de l'intervalle temporel entre la décharge de deux neurones.

Dessin schématique d'après Bi and Poo (1998)

Agus et al. ont pu mettre en 7vidence en 2010 l existence d un tel apprentissage pour le syst me auditif. Dans l exp7rience qu ils ont r7alis7e, des bruits gaussiens d une dur7e d une seconde 7taient pr7sent7s aux participants. Leur t che 7tait de d7terminer pour chacun des stimuli si la premi re partie du bruit (500ms) 7tait identique la deuxi me. Sans que les participants en soient inform7s, certains stimulus leur ont 7t7 pr7sent7s plusieurs fois durant l exp7rience. Pour ces stimuli, les exp7rimentateurs ont pu constater une augmentation rapide de la performance des sujets, sugg7rant l existence d un apprentissage.

Figure 3 - A: Sensibilité des sujets à la présence de répétition dans les bruits présentés une seule fois (gris) et ceux déjà présentés (rouge). B: Evolution des performances au

cours d’un bloc d’essais pour les bruits présentés une fois (gris) et ceux répétés (rouge). Extrait de Agus et al. (2010)

Par ailleurs, des réseaux de neurones s’appuyant sur la STDP capables de générer des neurones grand-mère ont pu être modélisés. Ces modèles ont des implications très intéressantes, ils suggèrent notamment que n’importe quel neurone peut devenir sélectif à un stimulus simplement si celui-ci est présenté plusieurs fois. Dans le modèle d’apprentissage de stimuli auditifs développé par Bichler, 25 présentations suffisent rendre un neurone s7lectif. L’une des questions essentielles soulevées alors, et qui est au c ur du projet M4, est donc de savoir si l’apprentissage et le stockage à long terme de stimuli sensoriels pourraient ne dépendre que du nombre de répétitions d’un stimulus. Ces modèles sont particulièrement intéressants et proposent une explication très satisfaisante de la façon dont la mémoire pourrait fonctionner. Tout l’enjeu est donc maintenant de mettre en évidence l’existence de ces mécanismes de spécialisation neuronale chez l’homme.

12

Ma mission

Dans le cadre de mon stage j’ai travaillé sur l’apprentissage de stimuli visuels en m’intéressant particulièrement à l’influence du nombre de présentations. L’objectif de mon stage était de développer un paradigme expérimental RSVP (Rapid Serial Visual Presentation) dans lequel la présentation de séquences d’images aléatoires et répétées génère une réponse localisée dans un champ hémisphérique afin d’étudier les mécanismes de spécialisation neuronale impliqués. Une originalité de ma mission a consisté àutiliser une méthode d’expérimentation innovante en proposant aux sujets de réaliser la tâche en ligne sur des tablettes. Ma mission peut être découpée en trois grandes parties que je présente dans la suite du rapport: Premier objectif: Développement du paradigme expérimental Deuxième objectif: Analyse des résultats préliminaires Troisi me partie: Am7 l ioration de l'application

13

DÉVELOPPEMENT DU PARADIGME EXPÉRIMENTAL

Mon travail a donc consist7 d7velopper un paradigme exp7rimental pour l 7tude des m7canismes de sp7cialisation neuronale concernant les stimuli visuels. Je vais bri vement pr7senter le fonctionnement du syst me visuel puis j expliquerai les choix qui ont 7t7 faits pour la construction de l exp7rience.

Concept ion du parad igme Le système visuel La perception de notre environnement visuel est bas7e sur la lumi re. Celle-ci, refl7t7e par les objets qui nous entourent, va atteindre notre il. Au fond de celui-ci, gr ce un syst me optique constitu7 notamment de la corn7e et du cristallin, une image de notre environnement va se former sur notre r7tine. Cette derni re est tapiss7e de photor7cepteurs qui vont pouvoir capter les photons et transmettre l information vers le cerveau. Ces premi res 7tapes du syst me visuel sont organis7es en couches hi7rarchis7es. chaque 7tape, le nombre de neurones repr7sentant le champ visuel diminue et c est la g7om7trie des connexions entre les couches qui va d7finir le traitement op7r7. Ainsi, chaque neurone fait un travail similaire : il d7charge en fonction de l'activit7 enregistr7e au niveau de ses synapses. Mais la g7om7trie bien sp7cifique des connexions entre les neurones permet de cr7er des d7tecteurs de contraste dans la r7tine, puis de barres orient7es dans le cortex visuel primaire (V1). Chaque neurone est associ7 un champ r7cepteur, c est- -dire une partie du champ visuel. Plus l on avance dans la hi7rarchie du syst me visuel, plus le nombre de neurones codant pour un champ r7cepteur diminue. Ainsi, les informations visuelles de notre environnement vont tre transform7es gr ce une suite de processus neuronaux en sensations perceptuelles. Tout le syst me est organis7 de fa on hi7rarchique, comme illustr7 sur la figure 4.

14

partir de V1 on assiste une sp7cialisation fonctionnelle, c est dire que diff7rentes voies neuronales vont traiter les diff7rents aspects de la sc ne visuelle (couleur, forme, mouvement,....). La derni re r7gion associ7e exclusivement aux traitements visuels est le cortex inf7ro-temporal. Toutes les r7gions de la voie visuelle se projettent finalement vers les diff7rentes structures composant le lobe temporal m7dian (MTL): amygdale, cortex entorhinal, cortex parahippocampique, cortex perirhinal et enfin hippocampe. Ces r7gions ne sont pas purement visuelles et leur r le a souvent 7t7 associ7 la m7moire (Squire et al., 2004). Cependant, plusieurs 7tudes ont 7galement mis en 7vidence leur r le dans le traitement visuel. Il a ainsi 7t7 montr7 par Kreiman et al. (2000) qu un grand nombre de cellules de ces r7gions r7pondaient s7lectivement diff7rentes cat7gories d objets telles que les visages, les animaux ou encore les maisons. L 7tude de Quian Quiroga et al. (2005) cit7e pr7c7demment est m me all7e plus loin en montrant qu une grande partie de ces neurones (40%) r7pondait de fa on extr mement s7lective et invariante des objets pr7cis. Ces observations tendraient consid7rer les neurones de cette r7gion comme de parfaits candidats pour le r le de neurones grand-m re. 15

Figure 4 - Organisation hiérarchique du système visuel. D'après Van Rullen (2003)

Le paradigme exp7rimental que j ai d7velopp7 vise donc mettre en 7vidence l existence de tels neurones en montrant qu il existe un apprentissage des stimuli visuels satisfaisant aux m7canismes STDP. Pour ce faire, nous avons utilis7 un protocole RSVP (Rapid Serial Visual Presentation).

Le protocole RSVP (Rapid Serial Visual Presentation) Le protocole RSVP, largement utilisé par la suite, a été développé par Molly Potter dès la fin des années 1960 (Potter and Levy, 1969). L’expérience initiale consistait à présenter aux sujets une série d’images différentes à un rythme plus ou moins rapide. Ceci permettait ensuite de déterminer la « résolution temporelle » du système visuel pour différentes tâches en fonction de la fréquence de présentation des images: détecter la présence d’un objet cible dans la série, dire si une image présentée a posteriori faisait ou non partie de la série. Ces expériences ont permis de mettre en évidence de façon quantitative les performances temporelles du système visuel.

Figure 5 - Illustration d'une séquence RSVP d'images. D'après Potter (2012) Dans le cadre du paradigme expérimental que nous avons développé, nous avons utilisé un protocole RSVP pour présenter aux sujets des séries d’images parmi lesquelles une image cible était répétée plusieurs fois. La tâche proposée aux sujets consistait à identifier l’image cible qui s’était répétée parmi un flux de distracteurs (images présentées une seule fois dans la série). Ce protocole est particuli rement int7ressant dans le cadre de l 7tude que nous avons r7alis7 car il permet notamment de modifier des param tres tels que le temps de pr7sentation des images, le nombre de r7p7titions de l image cible ou encore la distance temporelle entre deux images cibles. Par ailleurs, nous avons choisi de pr7senter parall lement deux flux d images, situ7s de part et d autre d une croix de fixation avec une 16

excentricit7 comprise entre 5,7 et 7,1 degr7s (la distance entre la croix de fixation et le centre de chaque image 7tant de 5cm et en consid7rant qu'un utilisateur tiendra l'iPad une distance de 40 50cm de ses yeux). Plusieurs 7tudes ont en effet montr7 qu il 7tait possible pour le syst me visuel de traiter en parall le plusieurs sc nes naturelles pr7sent7es simultan7ment des endroits diff7rents du champ visuel (Rousselet 2002,2003). De plus, en pr7sentant des s7ries d images excentr7es, on sollicite des neurones dont l'activit7 retient moins souvent notre attention que ceux dont le champ r7cepteur se situe au centre du champ visuel. Leur r7ponse est d autant plus int7ressante pour notre 7tude.

Le paradigme proposé Le paradigme que j’ai développé consistait donc à présenter aux sujets deux flux RSVP en parallèle situés de part et d’autre d’une croix de fixation (voir figure 6). La durée totale du flux ainsi que le nombre de répétitions de l image cible étaient variables. la fin de chaque série d’images, les sujets avaient pour tâche de répondre à la question suivante: « De quel côté une image est-elle apparue plusieurs fois? » )( . Une fois leur réponse donnée, ils devaient répondre à la question « Laquelle de ces images est apparue plusieurs fois? » par un choix forcé parmi quatre propositions: l’image cible qui avait été répétée, une image distracteur étant apparue au début du flux de droite, une image distracteur étant apparue au début du flux de gauche et une image leurre qu) n’avait jamais 7t7 vue (figure 8). Un message leur indiquait ensuite si ils avaient identifi7 ou non l image cible.

Figure 6 - Présentation du paradigme expérimental: Des images défilent rapidement de part et d'autre d'une croix de fixation. Dans l'un des flux, une image cible apparait plusieurs fois.

17

Figure 7 - Capture d'écran de la première question posée au sujet

Figure 8 - Capture d'écran du choix forcé: Le sujet doit identifier l'image répétée parmi 4 propositions, dont deux distracteurs présentés dans chacun des flux

lors de l'essai et une image leurre qu'il n'a jamais vue

18

Une originalité importante de cette expérience est qu’elle était proposée aux sujets sous forme d’une application iOS ludique t7l7charger sur iPad.

L’expérimentation innovante L 7tude des facult7s cognitives de l homme implique en g7n7ral la participation de petits groupes de volontaires qui se rendent dans les laboratoires pour effectuer des tests comportementaux sous la supervision des chercheurs. Cette m7thode pr7sente deux inconv7nients majeurs : recruter les sujets en nombre suffisamment 7lev7 pour obtenir des r7sultats fiables peut s av7rer complexe et dans la plupart des cas les participants constituent un groupe trop homog ne car leur recrutement se fait tr s largement parmi les 7tudiants en sciences cognitives. En parall le, Internet et les nouvelles technologies tels que les smartphones et les tablettes se sont d7velopp7es grande vitesse jusqu faire partie int7grante de notre quotidien. Ces outils pourraient permettre de faciliter le recrutement de sujets large 7chelle et de r7duire les co ts des exp7riences. De nombreux chercheurs commencent s int7resser tr s s7rieusement l utilisation de ces instruments qui pourraient bien r7volutionner la recherche en sciences cognitives.

partir du milieu des ann7es 1990, quelques pionniers ont commenc7 utiliser internet pour mener des recherches exp7rimentales en sciences cognitives. En 2002, Ulf-Dietrich Reips publie dans Experimental Psychology un article synth7tisant toutes les recommandations importantes pour d7velopper des exp7riences sur Internet. Bien qu ils aient pu tr s consid7rablement augmenter le nombre et l h7t7rog7n7it7 des participants, les chercheurs ont 7galement d faire face plusieurs difficult7s. L une des plus importantes concernait les diff7rences entre les diff7rents syst mes utilis7s par les participants (puissance de l ordinateur, d7bit internet, ) qui introduisaient trop de variance dans les r7sultats pour qu ils puissent tre concluants. De plus, les paradigmes cognitifs pr7sent7s sur internet ne permettent g7n7ralement pas d avoir acc s une pr7cision temporelle suffisante concernant la fois la pr7sentation des stimuli et l 7valuation du temps de r7ponse des sujets. Le d7veloppement des applications sur smartphones ou tablettes pr7sente une alternative particuli rement int7ressante car on conserve tous les avantages des exp7riences sur internet tout en s affranchissant du probl me de pr7cision temporelle. Aujourd hui, plusieurs laboratoires ont mis au point leurs propres applications pour mener leurs recherches. C est le cas notamment de l application ScienceXL d7velopp7e au Laboratoire de psychologie cognitive (Universit7 de Provence et CNRS) Marseille. L objectif de ScienceXL, t7l7chargeable gratuitement sur l AppStore est d'aider les chercheurs mieux comprendre notre habilet7 lire. Pour cela, les utilisateurs sont 19

invit7s tester leur connaissance du fran ais travers une t che tr s souvent employ7e dans les laboratoires, la t che de d7cision lexicale. Adapt7e dans plusieurs langues (anglais, allemand, espagnol, ) cette application a 7t7 le support d une 7tude internationale ayant rassembl7e 4157 participants en 4 mois et qui a donn7 lieu une publication dans PLoS One (Dufau et al. 2011).

Figure 9 - Captures d’écran de l’application ScienceXL développée au Laboratoire de

psychologie cognitive (Université de Provence et CNRS) dans le but d’étudier les capacités de lecture à grande échelle

Dans un article publi7 en 2012 (Lee et al. 2012) des chercheurs ont pu 7tudier l effet de l ge sur les facult7s cognitives gr ce une application d7velopp7e cette fin, BrainBaseline. Ils ont ainsi pu r7colter des donn7es pour plus de 15000 participants. Ce succ s s explique notamment par le travail r7alis7 sur l interface de l application qui permet aux utilisateurs de suivre leur progression et d 7valuer leurs capacit7s cognitives par rapport aux autres utilisateurs. Plusieurs applications proposent ainsi aux utilisateurs de r7aliser diff7rentes t ches dans le but d am7liorer leurs capacit7s cognitives tout en contribuant la collecte de donn7es pour les chercheurs. On peut 7galement citer l application Lumosity, et son Human Cognition Project qui vise r7colter un tr s grand nombre de donn7es pour faire avancer la recherche dans des domaines tels que la cognition, l apprentissage ou encore le sommeil en proposant un application disponible la fois sur iOS, android et sur le Web offrant au utilisateurs un suivi tr s

personnalis7 et un large 7ventail d activit7. Actuellement, plus de trois milliards de r7sultats sur des t ches cognitives ont ainsi pu tre enregistr7s, plus de 40 institutions de recherche ont particip7 au projet et pr s de 60 articles scientifiques ont ce jour 7t7 publi7s gr ce cette application.

20

Figure 10 - Présentation de l’application BrainBaseline

Figure 11 - Illustrations de la façon dont Lumosity adapte des tâches cognitives

développées par des chercheurs en des jeux pour ses utilisateurs Le 9 mars dernier Apple a annonc7 le lancement de Research Kit, un cadre logiciel Open Source con u pour la recherche dans le domaine de la m7decine et de la sant7. Lanc7e en avril 2012 aux Etats Unis, la plateforme regroupe d7j 5 applications d7di7es la maladie de Parkinson, aux maladies cardiovasculaires, au diab te, l'asthme et au cancer du sein.

21

Figure 12 - Captures d’écran d'applications Apple Research Kit

ResearchKit transforme l iPhone en un puissant outil de recherche m7dicale et facilite le recrutement des participants aux 7tudes de grande ampleur en acc7dant un vaste 7chantillon de population, et non aux seules personnes se situant proximit7 d une institution. Les participants l 7tude peuvent accomplir des t ches ou compl7ter des questionnaires et les envoyer depuis l application, ce qui permet aux chercheurs de consacrer moins de temps aux 7crits administratifs et plus l analyse des donn7es. ResearchKit permet aussi aux chercheurs de pr7senter un processus de consentement 7clair7 interactif. Les utilisateurs choisissent les 7tudes auxquelles ils participent et les donn7es qu ils souhaitent fournir dans le cadre de chacune. Cet outil prometteur offre aux chercheurs la possibilit7 de contribuer des modules d activit7 sp7cifiques dans ce cadre, comme des tests de m7moire et de d7marche, et de les partager avec la communaut7 mondiale des chercheurs afin de faire progresser les connaissances sur les maladies. Permettant de rassembler rapidement un grand nombre de participants et de donn7es, les smartphones et tablettes constituent donc ind7niablement un outil novateur et prometteur pour la recherche. En proposant une interface ludique et ergonomique l utilisateur ils rendent la recherche plus accessible au grand public et m7tamorphosent compl tement sa position et sa perception au sein de notre soci7t7.

22

Déve loppement de l ’app l ica t ion

L’équipe du projet M4 avait fait le choix avant mon arrivée de développer une application iOS, spécifiquement pour iPad. Après avoir choisi le langage de programmation et défini le cahier des charges de l’application, j’ai donc développé une application satisfaisant à nos différents besoins.

Environnement de développement J’ai utilisé l’environnement de développement Xcode (version 6.4) qui offre tous les outils nécessaires pour le développement d’applications iOS. Des captures d'7cran annot7es pr7sentant l'interface de d7veloppement sont fournies en annexes (Annexe 1). Pour développer l’application, j’ai choisi le langage Swift. Ce langage, relativement récent (la première version publique a été présenté en juin 2014 lors de la Apple Worldwide Developers Conference) est un langage de programmation multi-paradigmes développé par la société Apple. Principalement dédié à la réalisation d’applications iPhone, iPad, iPod touch et Mac OS X, il constitue une alternative plus simple, plus concise et plus rapide au langage Objective-C qu’il fallait nécessairement utiliser jusqu’ici.

Cahier des charges L application doit satisfaire un certain nombre de crit res. Elle doit en effet pr7senter certaines fonctionnalit7s, respecter certaines contraintes li7es aux objectifs scientifiques du projet et 7galement tre suffisamment ludique et ergonomique pour trouver et convaincre son public.

Fonctionnalité! L ’application doit permettre aux util isateurs

d ’effectuer la tâche expérimentale. La tâche sera répartie en blocs de plusieurs essais entre lesquels l’utilisateur pourra faire une pause afin de relâcher son attention. La consigne de la tâche doit être clairement expliquée et les utilisateurs commenceront par des essais d’entrainement afin de se familiariser avec la tâche. Après chaque réponse, un feedback sera donné à l’utilisateur afin de maintenir sa motivation dans la tâche.

! Dès le téléchargement de l’application, l’util isateur

doit avoir accès à une notice d ’informations concernant l’application, ses objectifs et son fonctionnement.

23

! L ’application doit permettre d ’enregistrer les résultats de l’util isateur (réponses et temps de réponse)

et de nous les rendre accessibles facilement pour notre étude.

! Pour que les résultats d’un utilisateur nous soient

accessibles, celui-ci devra donner son consentement et certifier avoir pris connaissance des conditions d’utilisation des données.

! L’utilisateur devra remplir un questionnaire le concernant (âge, genre,...) et auto-évalu sa concentration durant l’expérience. Ces données nous permettrons d’analyser les résultats avec plus de fiabilit7.

! L exp7rimentateur doit pouvoir modifier facilement les

param tres de la t che exp7rimentale.

Contraintes scientifiques • Chaque image distracteur ne doit être présentée qu’une seule fois

au cours de l’expérience pour éviter tout biais d’apprentissage. L’application doit donc pouvoir accéder à un très grand nombre d’images.

• Il faut maitriser précisément les temps d’apparition des images

ainsi que la mesure des temps de réponse.

Ergonomie/interface utilisateur • L’interface doit être agréable et ergonomique pour que l’application

soit simple d’utilisation.

• La tâche ne devra pas être trop longue, trop difficile et trop r7p7titive pour conserver un côté ludique et inciter les utilisateurs à participer.

• L’utilisateur aura accès à une rubrique lui permettant de visualiser

ses résultats et éventuellement de se positionner parmi les autres utilisateurs.

• Des prix seront mis en jeu afin d’encourager la participation des

utilisateurs. 24

Voici le diagramme des cas d utilisation construit partir du cahier des charges :

Figure 13 - Diagramme des cas d'utilisation de l'application BrainSpotting

Le développement Je présente ici les grandes 7tapes du d7veloppement, ainsi que les principales difficultés rencontrées lors de la phase de développement et les solutions proposées. Le script de la t che exp7rimentale comment7 ainsi que le storyboard de l application sont fournis en annexe (Annexes 2 et 3).

Gestion des images Dans le cadre de notre expérience, nous avons besoin d’une grande quantité d’images. En effet, nous souhaitons que chaque sujet puisse réaliser plusieurs dizaines d’essais sans qu’il ne revoie jamais les mêmes distracteurs. Ceci pr7sente un challenge important car les applications sont limitées en terme de quantité de données et les images sont des objets relativement lourds. Nous avons donc exploré plusieurs pistes pour optimiser la gestion de nos images:

• Réduction de la tail le des images Les images que nous avons utilisées ont été réduites aux dimensions 150x150 pixels et compressées au format jpeg (des informations concernant les images utilis7es sont fournies dans la suite du rapport). Sur l’iPad, les images sont affichées au format 300x300 pixels et ne sont donc pas très nettes. Ce choix a été fait car il permet d’obtenir des images de taille satisfaisante tout en conservant une qualité d’affichage suffisante 25

pour ne pas être désagréable pour l’utilisateur. Avec cette m7thode nous avons pu int7grer dans l'application un peu plus de 10 000 images.

• Méthode de stockage Il existe différentes façons de stocker et d’ouvrir des images dans une application. Nous avons choisi de stocker nos images dans un dossier de Ressources qu’il est possible d’ajouter dans les fichiers de l’application. En utilisant cette technique, il est ensuite possible de lire les images avec la méthode getUncachedImage qui pr7sente l'avantage de ne pas utiliser la m7moire cache (voir Annexe 2). Nous avions initialement choisi d'utiliser la m7thode UIImageNamed mais celle-ci stocke les images dans la m7moire cache ce qui avait pour cons7quence de provoquer quasi-syst7matiquement des crashs de l'application durant son utilisation pour cause de saturation de la m7moire.

Paramétrage de la tâche

L’une des fonctionnalités de notre application doit être de pouvoir modifier facilement certains paramètres sans avoir à effectuer une nouvelle soumission sur l'AppStore pour faire évoluer l’expérience. Dans un premier temps nous avons choisi les paramètres suivants: - Temps d’apparition des images - Position minimale de la première image cible dans le flux - Nombre de distracteurs minimal et maximal entre deux images cibles - Nombre de blocs - Nombre d’essais par bloc - Nombre d'essais d’entrainement - Date d’un concours et prix à gagner Afin de pouvoir accéder facilement à ces paramètres, nous avons déposé sur un serveur un fichier texte contenant les valeurs de ces paramètres et implémenté dans l’application une méthode de lecture systématique du fichier. Il est ainsi très aisé de modifier ce fichier et donc de faire varier les paramètres de l’expérience.

Enregistrement et transmission des données

L application doit permettre d enregistrer les r7sultats des utilisateurs et de les transmettre aux chercheurs. Nous avons pour cela retenu dans un premier temps une solution assez simple impl7menter : Chaque fois qu un utilisateur commence l exp7rience, un fichier texte est cr77 sur l'Ipad dans lequel les informations concernant le sujet sont enregistr7es. chaque essai, le fichier est incr7ment7 avec le r7sultat du sujet. Un exemple du fichier texte ainsi obtenu est fourni en annexe (Annexe 4). la fin de l exp7rience, il est propos7 au sujet de nous transmettre ses r7sultats par mail. Si il choisit de nous transmettre ses r7sultats, une interface mail 26

s ouvre automatiquement avec un mail pr7con u (destinataire, pi ces jointes, sujet,..) et il n a plus qu cliquer sur envoyer. Bien que cette m7thode fonctionne correctement, (m7thode utilis7e, par exemple, par l application ScienceXL) il serait int7ressant de pouvoir dans un second temps enregistrer automatiquement les r7sultats des sujets sur un serveur afin de faciliter le traitement des r7sultats par les chercheurs et de simplifier l'utilisation de l'application pour les participants.

Contrôle sur la fiabilité des données

L’un des inconvénients majeurs que pr7sente cette technique d exp7rimentation est que nous n avons plus de contr le que les conditions dans lesquelles les sujets ont pass7 l exp7rience et donc la fiabilit7 des donn7es recueillies. Afin de pallier en partie ce probl me, nous avons ajout7 la fin de l exp7rience un questionnaire d auto-7valuation dans lequel il est

demand7 au sujet d estimer sur une 7chelle de 1 10 sa concentration lors de l exp7rience, le nombre de personnes qui l entouraient et son respect de la consigne de fixer la croix (voir figure 14). Nous pouvons de cette fa on exclure les sujets qui n ont pas du tout fix7 la croix ou n 7taient pas assez concentr7s sur la t che.

Figure 14 - Questionnaire d'autoévaluation à remplir par les participants à la fin de

l'expérience

27

Aspect ludique et ergonomique Afin que l application attire les utilisateurs, nous avons accord7 un int7r t tout particulier au choix du nom de l application (BrainSpotting), au dessin du logo, la d7finition de la charte graphique de l application, ainsi qu l organisation de l application. Nous avons 7galement mis en place plusieurs niveaux de difficult7 ainsi que des concours avec des prix gagner pour encourager les utilisateurs participer. Le diagramme d activit7 de navigation de la premi re version de l application d7velopp7e est pr7sent7 sur la figure 15.

Val ida t ion e t d is t r ibu t ion Nous avons donc ce stade obtenu une premi re version de l application satisfaisant le cahier des charges et ne pr7sentant pas de bug. Apr s avoir effectu7 plusieurs tests de validation en interne, nous avons d7cid7 de soumettre cette version sur l AppStore et de lancer au m me moment une s7rie d exp7riences au laboratoire.

28

29 Figure 15 - D

iagramm

e d'activité de navigation

RÉSULTATS PRÉLIMINAIRES

Une �tude �t� r�alis�e au laboratoire afin d�obtenir des premiers r�sultats sur la t�che exp�rimentale mais �galement le retour des participants sur les aspects ludiques et ergonomiques de l�application. Ces r�sultats pr�liminaires nous ont par la suite permis d'effectuer de petits ajustements sur l'application.

Matér ie l e t méthode Pour cette �tude, chaque niveau �tait constitu� de 5 essais d�entrainement puis de 30 essais r�partis en 3 blocs de 10. Pour chaque sujet, les dur�es de pr�sentation �taient les m�mes mais dans un ordre al�atoire. Nous ne contr�lions en revanche pas le nombre de pr�sentations, susceptible alors de varier d�un sujet l�autre (voir Annexe 2). L�asynchronie d�apparition du stimulus (c�est dire l�intervalle de temps entre le d�but de la pr�sentation d�un stimulus et le d�but de celui qui lui succ�de) �tait fix�e respectivement 200 ms, 125 ms et 100 ms pour les niveaux facile, interm�diaire et difficile. Ceci correspond des fr�quences de 5, 8 et 10 images/seconde. Les images que j�ai utilis�es pour cette exp�rience sont extraites de la base de donn�es Corel Photo Gallery et leurs dimensions initiales �taient de 512x768 pixels. J�ai manuellement exclu toutes les images sur lesquelles apparaissaient des �tres humains, des visages humano�des ou du texte afin d��viter tout biais dans le traitement visuel car ces �l�ments sont connus pour attirer sp�cifiquement le regard et l'attention (Crouzet et al., 2010, Keysers 2001). J�ai �galement utilis� un logiciel de d�tection de doublons pour �liminer les images similaires ou tr�s proches.

Nous avons recrut� 33 sujets, �g�s de 18 59 ans (�ge moyen de 29 ans) parmi lesquels 23 �taient des femmes et 10 des hommes. L'histogramme des �ges est fourni en annexe (Annexe 5). Tous les sujets se sont rendus au laboratoire pour effectuer la t�che sur l'iPad. Chaque sujet s�installait dans un lieu calme et passait successivement les trois niveaux dans l�ordre qui lui �tait impos� par l�exp�rimentateur en commen�ant chaque nouveau niveau par 5 essais d'entra�nement. Nous contr�lions l'ordre de passage des niveaux pour �viter un effet d'apprentissage de la t�che dans nos r�sultats. Nous avons fait passer les sujets sur deux mod�les d'iPad diff�rents afin de mesurer �galement si ce param�tre avait un effet. Un tableau r�sumant les conditions de passage de chacun des sujets (ordre des niveaux et mod�le d'iPad) est donn� en annexe (Annexe 6).

30

Les sujets n��taient pas r�mun�r�s pour leur participation mais pour chacun des trois niveaux il y avait 20 euros en jeu pour le sujet qui effectuerait le meilleur score.

� la fin de chaque niveau, le participant nous transmettait ses r�sultats par mail, ainsi que les informations le concernant (�ge, sexe) et ses r�ponses au questionnaire d�auto�valuation de fin d�exp�rience (niveau de concentration, respect de la consigne de fixation et nombre de personnes autour de lui pendant l'exp�rience). Nous lui demandions �galement ses impressions sur l'application, la difficult� de la t�che et la strat�gie qu'il avait mis en place pour d�tecter les images r�p�t�es. Cette premi�re �tude nous a permis d�obtenir des r�sultats pr�liminaires int�ressants et des retours pertinents pour l�am�lioration de l�application.

Analyse des résu l ta ts L'analyse des r�sultats a �t� effectu�e avec Excel (notamment gr�ce des tableaux dynamiques et la suite StatPlus) et Matlab. Pour �tudier la significativit� de certains effets, j'ai effectu� des ANOVA (Analyse de la variance) avec un seuil de significativit� fix� 0,05. Nous avons notamment regard� les performances de localisation, qui correspondent au pourcentage de bonnes r�ponses la premi�re question:��De quel c�t� une image est-elle apparue plusieurs fois?��. Nous avons �galement �tudi� les performances en terme d�identification, c�est- -dire de r�ponses justes la question �Laquelle de ces images est apparue plusieurs fois?�� et enfin les performances de localisation+identification, c�est- -dire le pourcentage d'essais o� le sujet a identifi� le bon c�t� et la bonne cible simultan�ment. C�est ce dernier r�sultat qui correspond au score qui est attribu� au sujet et que nous avons utilis� pour d�terminer les gagnants du concours. Au niveau chance (c'est- -dire dans le cas o� le r�sultat ne d�pend que du hasard), pour chaque essai le sujet a donc une chance sur deux de choisir le bon c�t� pour la localisation et une chance sur quatre de s�lectionner la bonne image au moment du choix forc�. Le niveau chance pour la performance de localisation+identification est donc fix� 0,5x0,25=12,5% soit un score moyen de 3,75 sur 30. La plupart des graphes sont pr�sent�s avec des barres d'erreurs avec un �cart type et le seuil du niveau chance est trac� quand il est pertinent.

31

Effet de l 'âge, du genre et de l 'appareil uti l isé Nous n'avons constat� aucun effet significatif pour ces trois param�tres, comme illustr� ci-dessous.

Effet de l'âge Regardons dans un premier temps les performances moyennes d'identification sur les trois niveaux de difficult� confondus en r�partissant nos sujets en trois groupes d'�ge homog�nes.

Figure 16 - Effet de l'âge: perfomances d'identification sur l'ensemble des niveaux en fonction des groupes d'âges

On constate que les performances d'identification diminuent quand l'�ge moyen des participants augmente. Comme on peut le voir sur la figure 16, le groupe G1, dont l'�ge moyen est de 21 ans r�alise un score de 55,00% de cibles correctement identifi�es alors que l'on passe seulement 48,98% de cibles identifi�es pour le groupe G3 dont l'�ge moyen est de 38,2 ans. La diff�rence entre les trois groupes n'est cependant pas significative au seuil 0,05 (p=0,24).

55,00%

51,11% 48,98%

0%

20%

40%

60%

80%

100%

G1 - G2 - G3

Pourcentage de cibles identifiées

G1

G2

G3

32

G1: 10 participants âgés de 18 à 24 ans G2: 11 participants âgés de 25 à 28 ans G3: 9 participants âgés de 29 à 59 ans

Figure 17 - Effet de l'âge en fonction des niveaux: performances d'identification pour

chaque niveau en fonction des groupes d'âge

On constate �galement sur la figure 17 que la diff�rence entre les groupes est plus accentu�e pour le niveau difficile que pour les deux autres, m�me si le seuil de significativit� n'est pas atteint (p=0,17). Ces r�sultats sont en accord avec la litt�rature. Il est en effet av�r� que les performances cognitives se d�gradent avec l'�ge et notamment pour les t�ches visuelles (Lee et al., 2009).

Effet du genre On ne constate pas d'effet significatif du genre sur les performances d'identification (p=0,27), comme illustr� sur la figure 18.

Figure 18 - Effet du genre: performances d'identification sur l'ensemble des niveaux en

fonction du genre

Facile Intermédiaire Difficile G1 60,00% 51,33% 53,67%

G2 58,18% 48,48% 46,67%

G3 55,28% 47,22% 44,44%

0%

20%

40%

60%

80%

100%


G1

G2

G3

56,81% 47,83% 46,67%

59,67% 51,33% 51,00%

0%

20%

40%

60%

80%

100%

Facile Int Diff


Femmes

Hommes

33

Effet de l'appareil Il existe diff�rents mod�les d'iPad ne pr�sentant pas les m�mes caract�ristiques (dimension de l'�cran, param�tres affichage,...) et donc susceptibles d'avoir un effet sur les r�sultats de notre exp�rience. Nous ne disposions pour cette �tude que de deux mod�les (iPad mini et iPad Air) mais nous avons fait passer la moiti� des sujets sur chacun des mod�les pour pouvoir �valuer l'effet de ce facteur. Le score d'identification moyen obtenu avec l'iPad mini est de 49,70% tandis que celui obtenu sur l'iPad Air est de 53,02%. Les performances sont donc l�g�rement meilleures sur l'iPad Air (m�me si la diff�rence n'est pas significative, p=O,26). Ceci peut s'expliquer par les diff�rences entre ces deux mod�les pr�sent�es dans le tableau ci-dessous.

Effet d'apprentissage Afin de mesurer si il y avait un effet d'apprentissage de la t�che, nous avons compar� les scores des sujets sur chacun des niveaux en fonction de l'ordre dans lequel nous leur avions impos� de le passer.

Figure 19 - Effet d'apprentissage: Performances d'identification sur chacun des niveaux

en fonction de l'ordre de passage des sujets

Facile Intermédiaire Difficile 1er niveau passé 57,78% 45,00% 47,33%

2ème niveau passé 48,75% 49,58% 46,30%

3ème niveau passé 64,67% 51,11% 49,52%

Niveau chance 25% 25% 25%

0%

20%

40%

60%

80%

100%

Performances d'identification en fonction de l'ordre de passage

1er niveau passé

2ème niveau passé

3ème niveau passé

Niveau chance

iPad mini iPad Air

R�solution 2048x1536 pixels 326 pixels par pouce

2048x1536 pixels 264 pixels par pouce

Dimension 200x134,7mm 240x196,5mm

34

On constate que pour chacun des niveaux, les sujets qui ont r�alis� le meilleur score sont ceux qui l'ont pass� en dernier. L'effet de l'ordre de passage n'est cependant pas significatif (p=0,95).

Effet de la fréquence de défilement des images Regardons maintenant l'effet de la fr�quence de d�filement des images, c'est- -dire les diff�rences de performances entre les trois niveaux.

Figure 20 - Effet de la fréquence de défilement des images: Performances de localisation,

d'identification et de localisation+identification pour chacun de troix niveaux Pour la localisation, l'identification et la combinaison des deux, on observe des performances maximales pour le niveau facile et qui d�croissent quand on augmente le nombre d'images par seconde (figure 20). La diff�rence entre les performances d'identification des trois niveaux est significative (p=0,0026). On peut donc conclure que le nombre d'images par seconde influence la performance du sujet: plus les images d�filent lentement, plus les scores d'identification sont bons. Ceci rejoint les r�sultats de plusieurs �tudes (Vogel et al. 2010, Aky�rek et al. 2007, Rolls and Tovee, 1994). En effet, chaque image pr�sent�e constitue un masque qui va venir interf�rer avec le traitement des stimuli pr�sent�s juste avant ou apr�s. Dans un flux continu d'images le temps de traitement de l'information de chaque image est ainsi tr�s limit�, et ce d'autant plus que l'asynchronie d'apparition du stimulus est faible.

Localisation Identification Localisation+identification

Facile 66,58% 56,97% 46,97%

Intermédiaire 64,24% 48,14% 38,99%

Difficile 59,57% 48,31% 36,57%

0%

20%

40%

60%

80%

100%

Performances moyennes de l'ensemble des sujets sur chaque niveau

Facile

Intermédiaire

Difficile

Niveau chance

35

Effet du nombre de présentations Il s'agit de l'effet qui nous int�resse le plus dans le cadre de notre �tude. Dans cette premi�re exp�rience, le nombre de pr�sentations de l'image cible variait de 1 20 selon les essais, et ce quelque soit le niveau de difficult�. Les figures 21, 22 et 23 pr�sentent respectivement les scores de localisation, d'identification et d'identification+localisation en fonction du nombre de pr�sentations pour chacun des trois niveaux. Les r�sultats sont ici pr�sent�s en regroupant les nombres de pr�sentations et en affichant les erreurs types pour chaque point. Les courbes plus d�taill�es avec chaque nombre de pr�sentations en abscisse sont fournies en annexe (Annexe 7).

Figure 21 - Effet du nombre de présentations de la cible: performances de localisation pour

chacun des trois niveaux en fonction du nombre de présentations

0%

20%

40%

60%

80%

100%

1-4 5-8 9-12 13-16 17-20

Pour

cent

age

de c

ible

s lo

calis

ées

Nombre de présentations de la cible

Performances de localisation

Facile

Intermédiaire

Difficile

Niveau chance

36

Figure 22 - Effet du nombre de présentations de la cible: performances d'identification pour

chacun des trois niveaux en fonction du nombre de présentations

Figure 23 - Effet du nombre de présentations de la cible: performances de

localisation+identification pour chacun des trois niveaux en fonction du nombre de présentations

On peut constater que m�me pour un tr�s petit nombre de pr�sentations, les performances moyennes d�passent d�j le niveau chance.

0%

20%

40%

60%

80%

100%

1-4 5-8 9-12 13-16 17-20

Pour

cent

age

de c

ible

s id

entifi

ées


Performances d’identification

Facile

Intermédiaire

Difficile

Niveau chance

0%

20%

40%

60%

80%

100%

1-4 5-8 9-12 13-16 17-20

Pour

cent

age

de c

ible

s lo

calis

ées

et

iden

tifiée

s


Performances de localisation + d’identification

Facile

Intermédiaire

Difficile

Niveau chance

37

On constate, par ailleurs, l'existence d'un palier aux alentours de 10 pr�sentations. En effet, les performances semblent augmenter peu pr�s lin�airement jusqu' 10 pr�sentation puis ne plus beaucoup �voluer au del . Si l'on s'int�resse aux performances moyennes d'identification et d'identification+localisation pour les 10 premi�res pr�sentations, on constate que l'on s'approche fortement d'une r�gression lin�aire comme illustr� sur les figures 24 et 25.

Figure 24 - Effet du nombre de présentations de la cible: performances d'identification pour

chacun des trois niveaux et en moyenne avec la régression linéaire associée pour les essais où l'image cible est présentée entre 1 et 10 fois

Figure 25 - Effet du nombre de présentations de la cible: performances de

localisation+identification pour chacun des trois niveaux et en moyenne avec la régression linéaire associée pour les essais où l'image cible est présentée entre 1 et 10 fois

R² = 0,89913 0%

20%

40%

60%

80%

100%

0 1 2 3 4 5 6 7 8 9 10 11

Pour

cent

age

de c

ible

s id

entif

iées

Nombre de présentations

Performances d'identification

Facile

Intermédiaire

Difficile

Identification moyenne Linéaire (Identification moyenne)

R² = 0,95454

0%

20%

40%

60%

80%

100%

0 1 2 3 4 5 6 7 8 9 10 11

Pour

cent

age

de c

ible

s id

entif

iées

+loc

alis

ées

Nombre de présentations

Performances d'identification+localisation

Facile

Intermédiaire

Difficile

Moyenne

Linéaire (Moyenne)

38

Ces r�sultats confortent notre hypoth�se selon laquelle l'apprentissage serait une fonction lin�aire du nombre de pr�sentations d'un stimulus. De plus, on constate que le score d'identification est significativement plus �lev� que celui d'identification+localisation. En effet, il arrive fr�quemment que les sujets ne sachent pas r�pondre correctement la question de localisation mais reconnaissent imm�diatement l'image cible lorsque celle ci leur est pr�sent�e ensuite. Ceci sugg�re un apprentissage de l'image qui pourrait �tre implicite ou explicite.

Effet des images Certaines images semblent plus faciles identifier que d'autres. Il est int�ressant de regarder les caract�ristiques des images qui ont �t� identifi�es par les sujets. C'est pourquoi je me suis dans un premier temps attach�e la cat�gorisation des images puis l'�tude de quelques caract�ristiques de ces images.

Effet de la catégorie d'image Afin d'�tudier cet effet, j'ai manuellement cat�goris� toutes les images pour les r�partir en 4 grandes cat�gories: animal, paysage, objet et texture. Des exemples d'images de chacune des cat�gories sont fournis en annexe (Annexe 8). Regardons les performances d'identification pour chacune de ces cat�gories (figure 26).

Figure 26 - Effet de la catégorie des images: performances d'identification en fonction de la

catégorie d'images pour les essais où l'image cible est présentée entre 1 et 10 fois

0%

20%

40%

60%

80%

100%

1 2 3 4 5 6 7 8 9 10 Nombre de présentations

Performances d'identification pour les différentes catégories d'images

Animal

Objet

Paysage

Texture

39

On constate qu'il existe des diff�rences significatives entre ces cat�gories (p=2,84.10-9), avec notamment un score bien plus �lev� pour les images pr�sentant des animaux. Ce r�sultat corrobore ceux de la litt�rature existante ce sujet. Plusieurs �tudes ont en effet mis en �vidence le fait que les images d'animaux pouvaient �tre trait�es plus rapidement et plus efficacement que les autres (Kirchner and Thorpe 2006, Van Rullen 2000) et ce m�me si l'attention spatiale n'est pas dirig�e vers l'image (Fei-Fei et al., 2005). La catégorie "animal" pourrait constituer un cas particulier pour le traitement visuel, du fait de son importance biologique: les animaux ont toujours été présents aux côtés de l'homme au cours de l'évolution et porté une signification importante pour sa survie (nourriture, prédateur,...)

Notre capacit� m�moriser un stimulus visuel d�pendrait donc amplement du type de stimulus pr�sent�. De nombreuses �tudes s'attachent mesurer cet effet. Ceci pourrait �galement �tre li� au contenu s�mantique du stimulus, c'est dire la possibilit� ou non d'associer une description verbale simple (ex: un chien, un avion,...) contrairement des repr�sentations abstraites (ex: textures). Il serait particuli�rement int�ressant d'�tudier plus pr�cis�ment cet aspect dans le cadre de notre �tude.

Effet des caractéristiques des images

J'ai effectu� quelques mesures sur les caract�ristiques des images. J'ai notamment compar� l'aide de Matlab la luminance moyenne et le contraste moyen des images qui avaient �t� identifi�es et de celles qui ne l'avaient pas �t�. Pour calculer le contraste moyen de chaque image, j'ai utilis� la formule !"#$%&'$( = !!"#(!"#(:))!!"#(!"#(:))!"#(!"#(:))!!"#(!"#(:)) o� img correspond aux 3 matrices de dimensions 150x150 associ�es aux valeurs de chacun des pixels dans les plans rouge, vert et bleu. Pour le calcul de la luminance moyenne de chaque image, j'ai d'abord converti les images en niveaux de gris, puis j'ai calcul� la valeur moyenne des pixels de l'image. Sur l'ensemble des images identifi�es, j'ai mesur� un contraste moyen de 0,982 et une luminance moyenne de 103,23. Sur l'ensemble des images cibles qui n'ont pas �t� identifi�es, le contraste moyen �tait de 0,977 et la luminance moyenne de 103,43. Nous n'avons donc pas constat� de diff�rence significative mais cette �tude m�riterait d'�tre approfondie, avec une analyse, par exemple, des transform�es de Fourier des images pour d�terminer clairement les caract�ristiques des images qui influent sur leur identification. 40

Autres remarques Nous avons �galement pu constater que lors du choix forc�, les distracteurs (qui ont donc �t� pr�sent�s une fois au sujet) �taient plus souvent choisi que l'image leurre. Ceci sugg�re l'existence d'une forme d'apprentissage qui apparaitrait d�s la premi�re pr�sentation d'un stimulus. Il est surprenant de constater que cette diff�rence est d'autant plus importante que le nombre d'images par seconde est important (figure 27).

Figure 27 - Images choisies par les sujets au moment du choix forcé pour chacun des

trois niveaux de difficulté

Cible 57,69%

Distracteur 1 14,34%


Leurre 14,04%

Facile

Cible 48,89%



Leurre 15,56%

Intermédiaire

Cible 47,98%



Leurre 13,43%

Difficile

41

Il est aussi int�ressant de regarder si les cibles de droite ont �t� en moyenne aussi bien identifi�es que les cibles de gauche. En effet, plusieurs �tudes ont montr�es que dans le cas de la pr�sentation de deux flux RSVP en parall�le de chaque c�t� d'un �cran, l'attention �tait plus port�e vers le flux de gauche (Śmigasiewicz et al., 2010, Holländer et al., 2005). On retrouve ici une augmentation des performances pour le c�t� gauche: 26,30% des cibles pr�sent�es gauche ont �t� identifi�es contre 25,22% des cibles pr�sent�es droite.

Retour des sujets/stratégie/attention En interrogeant les sujets sur la strat�gie qu'ils avaient adopt�s pour la r�alisation de la t�che et en analysant les questionnaires d'auto-�valuation, nous avons pu constater que les sujets qui obtenaient les meilleures performances �taient ceux qui arrivaient maintenir leur regard fix� sur la croix tout en dirigeant leur attention vers les flux. Cette strat�gie s'est av�r�e bien plus efficace que celle retenue par certains sujets qui, ne parvenant pas traiter parall�lement les deux flux, fixaient alternativement l'un et l'autre des flux. Par ailleurs, les sujets rapportant un certain d�tachement par rapport la t�che ont �t� plus performants que ceux dont la strat�gie �taient d'essayer de m�moriser chacune des images pr�sent�es dans les flux. Concernant l'application, les sujets ont globalement donn�s un retour tr�s positif sur l'ergonomie et le design. Ils n'ont en revanche pas trouv� la t�che particuli�rement ludique et certains ont m�me trouv� celle-ci d�sagr�able. Il est donc n�cessaire de retravailler sur la t�che exp�rimentale pour la rendre plus attractive pour les utilisateurs et encourager leur participation. En tenant compte des r�sultats de cette premi�re �tude et des retours des participants, nous avons donc d�velopp�e une seconde version de l'application.

42

AMÉLIORATION DE L 'APPLICATION

Changements hors de la tâche Suite cette premi�re exp�rience j'ai l�g�rement modifi� les interfaces de l'application. J'ai notamment ajout� un avertissement concernant les crises d'�pilepsie photosensibles qui peuvent �tre d�clench�e par la t�che exp�rimentale chez certains sujets risques. J'ai �galement ajout� dans le questionnaire initial une question sur la lat�ralit� du sujet (droitier ou gaucher) car c'est un param�tre qui pourrait avoir un effet sur les r�sultats. Enfin j'ai effectu� quelques changements visant rendre l'application plus ergonomique pour les sujets (suppression de la correction automatique dans certains champs de texte comme l'adresse mail, adaptation des claviers par d�faut,...)

Changements de la tâche expér imenta le Simplif ication de la tâche Pour cette deuxi�me version nous avons avant tout cherch� rendre la t�che moins difficile et plus ludique pour les sujets. J'ai d'abord modifi� le retour donn� aux participants suite leur choix d'image: d�sormais nous leur montrerons l'image qui �tait la cible et leur indiquerons combien de fois celle-ci est apparue (voir figure 28).

Figure 28 - Retour donné à l'utilisateur suite à sa réponse au choix forcé 43

Nous nous sommes ensuite int�ress�s au rythme de pr�sentation des images cibles. Plusieurs �tudes ont en effet montr� qu'une r�p�tition p�riodique des stimuli facilitait leur apprentissage (Masquelier et al. 2009). Nous avions dans un premier temps choisi d'utiliser une dur�e al�atoire et variable entre chaque stimulus, nous allons maintenant la maintenir constante. Par ailleurs, la dur�e de certains essais �tant un peu trop longue et puisqu'il nous semble que les 10 premi�res pr�sentations sont les plus int�ressantes, nous nous limiterons d�sormais 10 pr�sentations de la cible au maximum par essai et nous fixerons une dur�e constante pour la pr�sentation des flux. Le tableau illustrant le design des nouveaux flux est donn� en annexe (Annexe 9). Cette fois le principe est donc que chaque flux contient un m�me nombre d'images, on fixe un nombre constant de distracteurs entre deux images cible successives mais le nombre de pr�sentations de l'image cible varie chaque essai (0, 1, 2, 4, 6, 8 ou 10 pr�sentations de l'image cible). Nous avons augment� le nombre d'essais pour lesquels l'image cible �tait pr�sent�e un grand nombre de fois afin de rendre la t�che plus simple. La premi�re position de l'image cible dans le flux est d�termin�e al�atoirement chaque essai avec pour seules contraintes que l'image cible ne soit pas parmi les 5 premi�res images du flux ni parmi les 5 derni�res. Le script comment� de cette version de la t�che exp�rimentale est fourni en annexe (Annexe 10). Cette version va pouvoir permettre de mesurer si la pr�sentation p�riodique des stimuli favorise leur apprentissage. L'objectif est �galement d'observer si il existe une fr�quence optimale pour l'apprentissage.

Le rôle des oscillations Les oscillations constituent un aspect important de l'activit� neuronale. On parle de rythme c�r�bral pour d�signer une oscillation �lectromagn�tique dans une bande de fr�quences donn�e r�sultant de l'activit� �lectrique coh�rente d'un grand nombre de neurones du cerveau. Les activit�s �lectriques c�r�brales sont class�es selon leurs fr�quences et associ�es des �tats de conscience: Alpha�: fr�quences comprises entre 8 et 12 Hz. Elles caract�risent un �tat de conscience apais�, et sont principalement �mises lorsque le sujet a les yeux ferm�s.

44

Beta �: correspond aux fr�quences sup�rieures 12�Hz (et g�n�ralement inf�rieures 45�Hz). Elles apparaissent en p�riode d�activit� intense, de concentration ou d�anxi�t�. Gamma: fr�quences sup�rieures 24�Hz, g�n�ralement d'environ 40�Hz. Elles ont �t� r�cemment impliqu�es dans les processus de liage perceptif�; Delta �: fr�quences jusqu� 4�Hz, normales chez le tr�s jeune enfant, elles peuvent ensuite caract�riser certaines l�sions c�r�brales�; Th�ta �: fr�quences entre 4,5 et 8�Hz. On les observe principalement chez l�enfant, l�adolescent et le jeune adulte. Elles caract�risent �galement certains �tats de somnolence ou d�hypnose, ainsi que lors de la m�morisation d'information. Si cette forme de p�riodicit� c�r�brale est connue depuis longtemps (Buzsaki 2006) plusieurs �tudes ont r�cemment sugg�r� que des processus comportementaux tels que l'attention ou la perception pourrait �galement fonctionner de fa�on p�riodique (Van Rullen 2007, Fiebelkorn et al. 2011, Landeau et al. 2012). Dans le cadre de notre �tude, on s'int�resse en particulier aux ondes alpha (8-12Hz) pr�sentes dans la partie occipitale du cerveau car plusieurs �tudes ont montr� que ce rythme c�r�bral pourrait jouer un r�le important dans le maintient des repr�sentations sensorielles court terme (Van Rullen et al., 2012) et les performances en terme d'attention et de perception (de Graff et al. 2013). Ainsi, nous pouvons faire l'hypoth�se qu'en pr�sentant nos images cibles p�riodiquement des fr�quences de la bande alpha, si nous parvenons synchroniser le rythme d'apparition des images cibles avec le rythme des oscillations occipitales, nous allons atteindre une forme de r�sonnance qui va potentiellement conduire une am�lioration des performances. Cette hypoth�se est tr�s int�ressante et c'est pourquoi c'est dans cette direction que nous allons s�rement orienter la suite de l'�tude. Il s'agira dans un premier temps de r�aliser des tests comportementaux comme dans l'exp�rience pr�liminaire, afin de mesurer si il existerait une fr�quence optimale pour l'apprentissage. Des exp�riences compl�mentaires en EEG permettront de mesurer les oscillations c�r�brales et donc d'�tudier directement le lien entre rythme de pr�sentation des stimuli, oscillations occipitales et performance du sujet. 45

BILAN ET PERSPECTIVES

Gr�ce notre premi�re s�rie d'exp�riences nous avons d�j pu mettre en �vidence plusieurs effets et il semblerait que notre hypoth�se concernant la lin�arit� de l'apprentissage par rapport au nombre de pr�sentations d'un stimulus se confirme. Comme nous avons pu le constater, l'application BrainSpotting constitue un outil puissant et prometteur pour l'�tude des processus neuronaux impliqu�s dans les t�ches de m�morisation visuelle. L'application a �t� approuv�e par Apple et est d�sormais disponible en t�l�chargement gratuit sur l'AppStore. Nous pouvons donc envisager la mise en place d'un grand nombre d'exp�riences diff�rentes, qui permettront, par exemple, d'�tudier plus sp�cifiquement l'effet des caract�ristiques des images (cat�gorie, contraste, contenu s�mantique,...) ou de la fr�quence de pr�sentation des cibles en collectant rapidement de tr�s nombreuses donn�es. En parall�le, le nouveau paradigme pourra �galement �tre utilis� pour des exp�riences en EEG ou en occulom�trie, par exemple, dans le but d'�tudier respectivement le r�le de param�tres tels que les oscillations c�r�brales ou l'engagement de l'attention dans la m�morisation de stimuli visuels.

46

BIBLIOGRAPHIE

Agus%TR,%Thorpe%SJ,%Pressnitzer%D.% (2010).%Rapid& Formation& of& Robust& Auditory&Memories:&Insights&from&Noise.%Neuron%66:610?8%

Akyürek,%E.%G.,%Hommel,%B.,%&% Jolicoeur,%P.% (2007).%Direct& evidence& for& a& role& of&working&memory&in&the&attentional&blink.%Memory%&%Cognition,%35(4),%621?627.%

Bi,%G.%Q.,%&%Poo,%M.%M.%(1998).%Synaptic&modifications& in& cultured&hippocampal&neurons:&dependence&on&spike&timing,&synaptic&strength,&and&postsynaptic&cell&type.%The%Journal%of%neuroscience,%18(24),%10464?10472.%

Bowers% JS.% 2009.% On& the& biological& plausibility& of& grandmother& cells:&Implications& for& neural& network& theories& in& psychology& and& neuroscience.%Psychol%Rev%116:220?51% Buzsaki,%G.%(2006).%Rhythms&of&the&Brain.%Oxford%University%Press.%

Crouzet,%S.,%Kirchner,%H.,%&%Thorpe,%S.%J.%(2010).%Fast&saccades& towards& faces:&Face&detection&in&just&100&ms.&Journal%of%vision%(Charlottesville,%Va.),%10(4),%1?17.%

Dufau,%S.,%Duñabeitia,%J.%A.,%Moret?Tatay,%C.,%McGonigal,%A.,%Peeters,%D.,%Alario,%F.%X.,%...%&%Grainger,%J.%(2011).&Smart&phone,&smart&science:&how&the&use&of&smartphones&can&revolutionize&research&in&cognitive&science.%PloS%one,%6(9),%e24974.%

Fei?Fei,%L.,%VanRullen,%R.,%Koch,%C.,%&%Perona,%P.% (2005).%Why& does& natural& scene&categorization&require&little&attention?&Exploring&attentional&requirements&for&natural&and&synthetic&stimuli.%Visual%Cognition,%12(6),%893?924.%

Fiebelkorn% IC,% Foxe% JJ,% Butler% JS,%Mercier%MR,% Snyder% AC,% et% al.% (2011)& Ready,& set,&reset:& stimulusOlocked& periodicity& in& behavioral& performance& demonstrates&&the&consequences&of&crossOsensory&phase&reset.%J%Neurosci%31:%9971–9981.!!!

de%Graaf,%T.%A.,%Gross,%J.,%Paterson,%G.,%Rusch,%T.,%Sack,%A.%T.,%&%Thut,%G.%(2013).%AlphaOband&rhythms&in&visual&task&performance:&phaseOlocking&by&rhythmic&sensory&stimulation.%

Gross%CG.%2002.%Genealogy&of&the&"Grandmother&Cell".%Neuroscientist%8:84?90%

Hebb% DO.% 1949.% The& Organization& of& Behaviour& :& A& Neuropsychological&Perspective.%New%York:%Wiley%

Holländer,% A.,% Corballis,%M.%C.,% &%Hamm,% J.% P.% (2005).%VisualOfield& asymmetry& in&dualOstream&RSVP.%Neuropsychologia,%43(1),%35?40.%

Keysers,%C.,%Xiao,%D.,%Földiák,%P.,%&%Perrett,%D.%(2001).%The&speed&of&sight.%Cognitive%Neuroscience,%Journal%of,%13(1),%90?101.%

47

Kirchner,%H.,%&%Thorpe,% S.% J.% (2006).%UltraOrapid& object& detection& with& saccadic&eye&movements:&Visual&processing& speed& revisited.%Vision!research,%46(11),%1762?1776.%

Kreiman,% Gabriel,% Christof% Koch,% and% Itzhak% Fried.% "CategoryOspecific& visual&responses& of& single& neurons& in& the& human& medial& temporal& lobe."% Nature!neuroscience%3.9%(2000):%946?953.%

Landau% AN,% Fries% P% (2012)% Attention& samples& stimuli& rhythmically.% Current%%biology%22:%1000–1004.%%

Lee,%T.%Y.,%&%Hsieh,%S.%(2009).%The& limits& of& attention& for& visual& perception& and&action&in&aging.%Aging,%Neuropsychology,%and%Cognition,%16(3),%311?329.%

Lee,%H.,%Baniqued,%P.%L.,%Cosman,%J.,%Mullen,%S.,%McAuley,%E.,%Severson,%J.,%&%Kramer,%A.%F.% (2012).%Examining& cognitive& function& across& the& lifespan& using& a&mobile&application.&Computers!in!Human!Behavior,%28(5),%1934?1946.%

Masquelier% T,% Thorpe% SJ.% 2007.% Unsupervised& Learning& of& Visual& Features&through&Spike&Timing&Dependent&Plasticity.%PLoS!Comput!Biol!3:e31%

Masquelier%T,%Guyonneau%R,%Thorpe%SJ.%2008.%Spike& timing& dependent& plasticity&finds& the& start& of& repeating& patterns& in& continuous& spike& trains.% PLoS% ONE%3:e1377%

Masquelier,%T.,%Hugues,%E.,%Deco,%G.,%&%Thorpe,%S.%J.%(2009).%Oscillations,&phaseOofOfiring& coding,& and& spike& timingOdependent& plasticity:& an& efficient& learning&scheme.%The!Journal!of!neuroscience,%29(43),%13484?13493.%

Potter,%Mary%C.,%and%Ellen%I.%Levy.%"Recognition&memory& for&a&rapid&sequence&of&pictures."&Journal!of!experimental!psychology%81.1%(1969):%10.%

Potter,% Mary% C.% "Recognition& and& memory& for& briefly& presented& scenes."%Frontiers!in!psychology%3%(2012). %

Quian% Quiroga% R,% Reddy% L,% Kreiman% G,% Koch% C,% Fried% I.% 2005.% Invariant& visual&representation&by&single&neurons&in&the&human&brain.%Nature!435:1102?7%

Quiroga,%R.%Q.,%Reddy,%L.,%Koch,%C.,%&%Fried,%I.%(2007).%Decoding&visual&inputs&from&multiple&neurons&in&the&human&temporal&lobe.%Journal!of!neurophysiology,%98(4),%1997?2007.%%Quiroga,% R.% Q.,% Kreiman,% G.,% Koch,% C.,% &% Fried,% I.% (2008).% Sparse& but& not&‘grandmotherOcell’coding& in& the& medial& temporal& lobe.% Trends! in! cognitive!sciences,%12(3),%87?91%%Reips,%U.%D.% (2002).%Standards& for& InternetObased& experimenting.%Experimental!psychology,%49(4),%243?256.%%

48

Rolls,%E.%T.,%&%Tovee,%M.%J.%(1994).%Processing&speed&in&the&cerebral&cortex&and&the&neurophysiology&of&visual&masking.%Proceedings!of!the!Royal!Society!of!LondonIBIBiological!Sciences,%257(1348),%9?16. %Rousselet,% Guillaume% A.,% Michèle% Fabre?Thorpe,% and% Simon% J.% Thorpe.% "Parallel&processing&in&highOlevel&categorization&of&natural&images."%Nature!neuroscience%5.7%(2002):%629?630.%%Rousselet,% Guillaume% A.,% Marc% J?M.% Macé,% and% Michèle% Fabre?Thorpe.% "Is& it& an&animal?& Is& it& a& human& face?& Fast& processing& in& upright& and& inverted&natural&scenes."%Journal!of!vision%3.6%(2003):%5.%%Śmigasiewicz,%K.,%Shalgi,%S.,%Hsieh,%S.,%Möller,%F.,%Jaffe,%S.,%Chang,%C.%C.,%&%Verleger,%R.%(2010).%Left& visualOfield&advantage& in& the&dualOstream&RSVP& task&and& readingOdirection:&A&study&in&three&nations.%Neuropsychologia,%48(10),%2852?2860.%Squire,% Larry% R.% "Memory& systems& of& the& brain:& a& brief& history& and& current&perspective."%Neurobiology!of!learning!and!memory%82.3%(2004):%171?177.%%Thorpe% SJ.% 2011.& Grandmother& Cells& and& Distributed& Representations.& In&Understanding, visual, population, codes, 3, Towards, a, common, multivariate&framework& for& cell& recording& and& functional& imaging,% ed.% N% Kriegeskorte,% G%Kreiman.%Cambridge:%MIT%Press%

Vanrullen,%R.%(2000).%Une&première&vague&de&potentiels&d'action,&une&première&vague&idée&de&la&scène&visuelleOrôle&de&l'asynchronie&dans&le&traitement&rapide&de& l'information&visuelle%(Doctoral%dissertation,%Université%Paul%Sabatier?Toulouse%III).%

VanRullen,% Rufin.% "Visual& saliency& and& spike& timing& in& the& ventral& visual&pathway."%Journal!of!PhysiologyIParis%97%(2003):%365?377.%

VanRullen%R,%Carlson%T,%Cavanagh%P%(2007)%The& blinking& spotlight& of& attention.%Proc%Natl%Acad%Sci%U%S%A%104:%19204–19209.%%

VanRullen% R,% Macdonald% JS% (2012)% Perceptual& echoes& at& 10& Hz& in& the& human&&brain.%Current%biology%22:%995–999.%%%Vogel,% E.% K.,% Woodman,% G.% F.,% &% Luck,% S.% J.% (2006).& The& time& course& of&consolidation& in& visual& working& memory.% Journal! of! Experimental! Psychology:!Human!Perception!and!Performance,%32(6),%1436.%

49

ANNEXES

Annexe 1: Environnement de développement Xcode.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .51 Annexe 2 : Script de la tâche expérimentale dans la version 1.. . . . . . . . . . . . .52 Annexe 3: Storyboard de l 'application (version 1). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .66 Annexe 4: Exemple de fichier résultats transmis par mail au chercheur.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .67 Annexe 5: Histogramme des âges des participants à l 'expérience.. . . . . . . .68 Annexe 6: Conditions de passage des sujets.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .69 Annexe 7: Performances de localisation et identif ication pour chaque nombre de présentations.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .70 Annexe 8: Exemple d'images appartenant à chacune des quatre catégories.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71

Annexe 9: Design des flux de la version 2 de l 'application.. . . . . . . . . . . . . . . . . . . .73 Annexe 10: Script de la tâche expérimentale dans la version 2.. . . . . . . . . . . . .74

50

Annexe 1 : Environnement de développement Xcode

Annexe 1.1 - Environnement de développement (éditeur de code)%

Annexe 1.2 - Environnement de développement (éditeur visuel)

51

Annexe 2 : Script de la tâche expérimentale dans la version 1

// // ViewController.swift // ProjetRSVP // // Created by Camille on 20/05/2015. // All rights reserved. // import UIKit import Foundation class ViewController: UIViewController { // Déclaration des variables // Objets graphiques définis sur le storyboard associés au ViewController @IBOutlet weak var imageView1: UIImageView! @IBOutlet weak var imageView2: UIImageView! @IBOutlet weak var imageView: UIImageView! @IBOutlet weak var choixCible1: UIImageView! @IBOutlet weak var choixCible2: UIImageView! @IBOutlet weak var choixCible3: UIImageView! @IBOutlet weak var choixCible4: UIImageView! @IBOutlet weak var choix1Button: UIButton! @IBOutlet weak var choix2Button: UIButton! @IBOutlet weak var choix3Button: UIButton! @IBOutlet weak var choix4Button: UIButton! @IBOutlet weak var startButton: UIButton! @IBOutlet weak var leftButton: UIButton! @IBOutlet weak var rightButton: UIButton! @IBOutlet weak var myLabel: UILabel! @IBOutlet weak var makeAChoice: UILabel! @IBOutlet weak var homeButton: UIButton! @IBOutlet weak var sendButton: UIButton! // Lecture du fichier txt sur le serveur var url:NSURL = DataContainerSingleton.sharedDataContainer.URLvalid // récupération de l'URL du document qui a été déterminée et enregistrée dans le Singleton à l'ouverture de l'application var error: NSErrorPointer = nil // variable utile pour la lecture var lines = [String]() // variable utile pour la lecture var values = [String]() // variable utile pour la lecture // Variables récupérée dans le fichier txt var xmlVersion = String() // version du fichier var posMin = UInt32() // Nombre d'images minimum qui doivent être présentées avant la première cible dans un essai var distMin = Int() // Nombre d'images distracteurs minimum entre deux images cibles successives var distMax = Int() // Nombre d'images distracteurs maximum entre deux images cibles successives var entrainement = Int() // Nombre d'essais d'entrainement au début de chaque session var essai = Int() // Nombre d'essai dans un bloc var bloc = Int() // Nombre de bloc dans une session var freq = UInt32() // Nombre d'images/seconde // Construction des flux d'images var levelSaved:Int = DataContainerSingleton.sharedDataContainer.level // Variable niveau (Facile, Intermédiaire ou Difficile) determinée dans l'interface de choix du niveau et stocké dans le Singleton var decal = UInt32() // Pour prendre le stock d'images associé au niveau choisi var distractorArrayName = [String]() // Tableau contenant le nom des images distracteurs var targetArrayName = [String]() // Tableau contenant le nom des images cibles var leurreArrayName = [String]() // Tableau contenant le nom des images 52

leurres

var distractorArray = [UIImage]() // Tableaux des images distacteurs var targetArray = [UIImage]() // Tableaux des images cibles var fluxSize = [Int]() // Vecteur contenant la liste des durées des différents flux d'une session mélangé aléatoirement pour chaque sujet var vectorSize = UInt32() // Nombre d'images dans un flux var randomNumber = UInt32() // pour déterminer la position alétoire de la première cible var rangerand = Int() // Nombre alétoire entre distMin et distMax pour déterminer les positions des images cibles var vectorTarget = [UInt32]() // Vecteur positions des cibles dans le flux d'images var flux1Name = [String]() // Vecteur noms des images dans le flux 1 var flux2Name = [String]() // Vecteur noms des images dans le flux 2 var flux1 = [UIImage]() // Vecteur images du flux 1 var flux2 = [UIImage]() // Vecteur images du flux 2 var X = UIImageView() // ImageView où apparait un flux var Y = UIImageView() // ImageView où apparait l'autre flux var randomPosition: UInt32 = 0 // Déterminer alétoire le côté (droite ou gauche) du flux contenant l'image cible // variable pour le choix du côté et de l'image par le sujet var goodRep:Bool = false // Booléen bonne ou mauvaise réponse pour lacalisation var random1 = Int() // Choisir une image alétoirement au début du flux 1 pour choix forcé var random2 = Int() // Choisir une image alétoirement au début du flux 2 pour choix forcé var choiceArray = Array<UIImage>() // Tableau contenant les images proposée pour le choix forcé (image 1, image 2, image 3, image 4) var image1 = UIImage() // image cible var image2 = UIImage() // image leurre var image3 = UIImage() // distracteur 1 var image4 = UIImage() // distracteur 2 // Enregistrement des Résultats let theFileManager = NSFileManager.defaultManager() let documentsFolderForSavingFiles = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as! String // Répertoire de stockage des fichiers résultats var fileName = "" // Nom du fichier d'enregistrement des résultats qui seront envoyés à la fin de l'expé var myPath = "" // Chemn complet d'accès au fichier pour enregistrement résultats var fileSave = "" // Nom du fichier de stockage du score pour affichage interne iPad var txtFinal:String= DataContainerSingleton.sharedDataContainer.mail. stringByAppendingString(DataContainerSingleton.sharedDataContainer.infoSujet) // Texte final à écrire. Initialiser avec infos sujets contenues dans Singleton var pseudoSaved: String = DataContainerSingleton.sharedDataContainer.pseudo // Pseudo du participant, récupéré dans singleton var savedTxtFile:String = "" // Texte à enregistrer dans le fichier résultats, incrémenté à chaque essai (étape localisation) var txtToSave: String = "" // Texte à enregistrer dans le fichier résultats, incrémenté à chaque essai (étape choix forcé) var monScore: Score? // Stock un résultat sous la forme monScore(score, identify, date, level, pseudo) pour afficher résultat joueur dans l'appli // Compteurs var nbloc = 0 // Compteur du nombre de bloc incrémenter à chaque changement de bloc var nessai = 0 // Compteur du nombre d'essais réalisés implémenté à chaque essai var good = 0 // Compteur bonnes réponses localisation implémenté à chaque essai var goodTarget = 0 // Compteur cibles correctement identifiées quand bonne localisation var i = 0 var m = 0 var n = 0 // Variables temps var dureeAnimation = NSTimeInterval() // Duréé de l'animation var timer = NSTimer() // Timer utilisé pour le lancement du choix réponse à la fin de l'animation var startFlux = NSDate() // DaTE lancement du flux (pour calcul temps de réponse) 53

var startChoice = NSDate() // Date choix côté (pour calcul temps de réponse) // Bloquer l'orientation de l'iPad (en mode paysage pour la tâche) override func supportedInterfaceOrientations() -> Int { return Int(UIInterfaceOrientationMask.LandscapeLeft.rawValue) } override func preferredInterfaceOrientationForPresentation() -> UIInterfaceOrientation { return .LandscapeLeft } // ----------------------------- Fonction chargement de la vue ---------------------------- override func viewDidLoad() { super.viewDidLoad() // Pour maintenir l'orientation de l'iPad let value = UIInterfaceOrientation.LandscapeLeft.rawValue UIDevice.currentDevice().setValue(value, forKey: "orientation") // Ne pas afficher de bouton retour self.navigationItem.setHidesBackButton(true, animated:true) // Lecture du fichier txt sur le serveur / chargement des valeurs des paramètres let data = String(contentsOfURL: url, error: error) let newline = NSCharacterSet.newlineCharacterSet() var data2 = data!.stringByTrimmingCharactersInSet(newline).enumerateLines { line, stop in self.lines.append(line) } values = lines[0].componentsSeparatedByString(":") xmlVersion = values[1] values = lines[4].componentsSeparatedByString(":") posMin = UInt32(values[1].toInt()!) values = lines[5].componentsSeparatedByString(":") distMin = values[1].toInt()! values = lines[6].componentsSeparatedByString(":") distMax = values[1].toInt()! values = lines[7].componentsSeparatedByString(":") entrainement = values[1].toInt()! values = lines[8].componentsSeparatedByString(":") essai = values[1].toInt()! values = lines[9].componentsSeparatedByString(":") bloc = values[1].toInt()! if (levelSaved == 1 ) { values = lines[10].componentsSeparatedByString(":") } else if (levelSaved == 2){ values = lines[11].componentsSeparatedByString(":") } else { values = lines[12].componentsSeparatedByString(":") } freq = UInt32(values[1].toInt()!) rangerand = distMax - distMin // Détermine la date et l'heure actuelle pour nom du fichier résultat let date = NSDate() // Convertion NSDate en String var formatter: NSDateFormatter = NSDateFormatter() formatter.dateFormat = "dd-MM-yyyy_HH:mm:ss" let stringDate: String = formatter.stringFromDate(date) // Enregistre le modèle de l'ipad let device = UIDevice.currentDevice().modelName // Première données à enregistrer txtFinal = txtFinal.stringByAppendingString("\(xmlVersion)/\(levelSaved)/\(stringDate) /\(device)\n\n") // Fichiers pour enregistrement fileName = "/\(stringDate).txt" 54

fileSave = "/saveResults.plist" myPath = documentsFolderForSavingFiles.stringByAppendingString(fileName) DataContainerSingleton.sharedDataContainer.filePath = fileName //Texte à afficher au lancement makeAChoice.text = "Phase d'entraînement" myLabel.text = "Appuyer sur START pour démarrer l'entraînement" // Cacher et désactiver les boutons réponses sendButton.hidden = true sendButton.enabled = false choix1Button.enabled = false choix2Button.enabled = false choix3Button.enabled = false choix4Button.enabled = false leftButton.hidden = true rightButton.hidden = true leftButton.enabled = false rightButton.enabled = false // Construction des tableaux contenant les noms des images // Stock d'image correspondant au niveau if (levelSaved==2) { decal = 3800 } if (levelSaved==3) { decal = 7600 } else { decal = 0 } // Choix aléatoire d"une première cible et d'un premier leurre parmi le répertoire d'image var t = arc4random_uniform(49) + 1 + decal targetArrayName = ["d\(t)"] leurreArrayName = ["d\(t+20)"] // Construction des vecteurs noms des cibles et noms des distracteurs (tirage aléatoire) for i in 1...34 { t = t + 50 + arc4random_uniform(50) targetArrayName.append("d\(t)") leurreArrayName.append("d\(t+20)") } // Construction du vecteur distracteurs contenant toutes les images restant dans le répertoire for i in (decal+1)...(decal+3800) { if ( targetArrayName[m] == "d\(i)" && m<34 ) { m = m+1 } else { if ( leurreArrayName[n] == "d\(i)" && n<34 ) { n = n+1 } else { if ( targetArrayName[m] != "d\(i)" && leurreArrayName[n] != "d\(i)" ) { distractorArrayName.append("d\(i)") } } } } // Tableau durée des flux fluxSize = [1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9] // Mélange des tableaux de noms des distracteurs for var index = distractorArrayName.count - 1; index > 0; index-- { var j = Int(arc4random_uniform(UInt32( index - 1))) swap(&distractorArrayName[index], &distractorArrayName[j]) } 55

// mélange cibles for var index = targetArrayName.count - 1; index > 0; index-- { var j = Int(arc4random_uniform(UInt32( index - 1))) swap(&targetArrayName[index], &targetArrayName[j]) println(j) } // mélange leurres for var index = leurreArrayName.count - 1; index > 0; index-- { var j = Int(arc4random_uniform(UInt32( index - 1))) swap(&leurreArrayName[index], &leurreArrayName[j]) } // Mélange durée flux for var index = fluxSize.count - 1; index > 0; index-- { var j = Int(arc4random_uniform(UInt32(index))) swap(&fluxSize[index], &fluxSize[j]) } // Enregistrement des vecteurs nom images dans le fichier résultat txtFinal = txtFinal.stringByAppendingString("\(distractorArrayName)\n\ (targetArrayName)\n\(leurreArrayName)\n\n") // Appel de la fonction pour construire les flux constructionFlux() } //----------------------------------Construction des flux----------------------------------- func constructionFlux() { randomNumber = arc4random_uniform(UInt32(distMax-1)) + posMin // Réinitialiser tous les vecteurs rmepli à la précédente itération vectorTarget.removeAll() flux1.removeAll() flux2.removeAll() flux1Name.removeAll() flux2Name.removeAll() // Initialisation du vecteur position des cibles vectorTarget.append(randomNumber) // Calcul du nombre d'images dans le flux en fonction du vecteur fluxSize vectorSize = 10 * UInt32(fluxSize[nessai]) // Calcul de la durée de l'animation en divisant le nombre d'images par a fréquence dureeAnimation = NSTimeInterval(vectorSize/freq) // remplissage du vecteur position des cibles var k = 0 while ((vectorTarget[k])<vectorSize) { randomNumber=arc4random_uniform(UInt32(rangerand+1 )) vectorTarget.append(vectorTarget[k]+randomNumber+UInt32(distMin)) k++ } if (vectorTarget[k]+randomNumber+UInt32(distMin) >= vectorSize) { vectorTarget.removeLast() } // Construction des flux d'iamages 1 et 2 var j:Int = 0 while (flux1.count<Int(vectorSize)) { println(distractorArrayName[i+1]) 56

flux1.append(getUncachedImage(named:"\(distractorArrayName[i+1]).jpg")!) flux1Name.append(distractorArrayName[i+1]) i=i+1 flux2.append(getUncachedImage(named:"\(distractorArrayName[i+1]).jpg")!) flux2Name.append(distractorArrayName[i+1]) i=i+1 var x = UInt32(flux1.count) if (j<vectorTarget.count && x == vectorTarget[j] ) { flux1.append(getUncachedImage(named:"\(targetArrayName[nessai]).jpg")!) flux1Name.append(targetArrayName[nessai]) flux2.append(getUncachedImage(named:"\(distractorArrayName[i+1]).jpg")!) flux2Name.append(distractorArrayName[i+1]) i=i+1; j=j+1; } } // Choix aléatoire du coté d'apparition des flux var tabloImageView: [UIImageView] = [imageView1,imageView2] randomPosition = arc4random_uniform(2) var randomPositionInt = Int(randomPosition) X = tabloImageView[randomPositionInt] if (randomPosition == 1) { Y = tabloImageView[0] } else { Y = tabloImageView[1] } } // -------------------------------------------- Croix de fixation -------------------------- // Apparition de la croix de fixation 1 seconde après appui sur boutton START @IBAction func animation(sender: UIButton) { var animCross = [UIImage]() animCross.append(UIImage(named:"cross.jpg")!) delay(1.0){ self.imageView.animationImages = animCross self.imageView.animationRepeatCount = 1 self.imageView.animationDuration = (2 + self.dureeAnimation) self.imageView.startAnimating() } } // --------------------------------------- didReceiveMemoryWarning ------------------------- override func didReceiveMemoryWarning() { super.didReceiveMemoryWarning() // Vérification pas de problème de mémoire. Si pb --> crash appli } // ----------------------------------------- startAnimation ------------------------------- @IBAction func startAnimation(sender: UIButton) { // lancement de l'animation suite à appui bouton START goodRep = false 57

// lancement du chois côté après délai fixé timer = NSTimer.scheduledTimerWithTimeInterval((dureeAnimation + 3.3), target:self, selector:Selector("makeYourChoice"), userInfo: nil, repeats:false) // réglage boutons startButton.hidden = true startButton.enabled = false homeButton.hidden = true homeButton.enabled = false // Pas de texte à afficher self.myLabel.text = "" makeAChoice.text = "" // Lancement flux après délai fixé delay(3.0){ startFlux = NSDate() self.X.animationImages = self.flux1 self.X.animationRepeatCount=1 self.X.animationDuration = self.dureeAnimation self.X.startAnimating() self.Y.animationImages = self.flux2 self.Y.animationRepeatCount=1 self.Y.animationDuration = self.dureeAnimation self.Y.startAnimating() } } // -------------------------------- makeYourChoice (localisation)--------------------------- func makeYourChoice() { // choix droite ou gauche startChoice = NSDate() leftButton.hidden = false rightButton.hidden = false self.leftButton.enabled = true self.rightButton.enabled = true nessai = nessai + 1 self.makeAChoice.text = " De quel côté une image est-elle apparue plusieurs fois?" } // ----------------------------------------- rightPress ------------------------------------ @IBAction func rightPress(sender: UIButton) { var endChoice = NSDate() var tempsReponse:NSTimeInterval = endChoice.timeIntervalSinceDate(self.startChoice) leftButton.enabled = false rightButton.enabled = false self.makeAChoice.text = " Laquelle de ces images est apparue plusieurs fois?" // Sélection des images pour choix forcé et disposition aléatoire random1 = Int(arc4random_uniform(5))+5 random2 = Int(arc4random_uniform(5))+5 image1 = getUncachedImage(named:"\(targetArrayName[nessai-1]).jpg")! image2=getUncachedImage(named:"\(leurreArrayName[nessai-1]).jpg")! if (flux1Name[random1] != targetArrayName[nessai-1]) { image3 = flux1[random1] } else {image3 = flux1[random1-1] } image4=flux2[random2] choiceArray = [image1, image2, image3, image4] 58

for var idx = 3; idx > 0; idx-- { var p = arc4random_uniform(UInt32(idx+1)) swap(&choiceArray[idx], &choiceArray[Int(p)]) } choixCible1.image = choiceArray[0] choixCible2.image = choiceArray[1] choixCible3.image = choiceArray[2] choixCible4.image = choiceArray[3] choix1Button.enabled = true choix2Button.enabled = true choix3Button.enabled = true choix4Button.enabled = true // Enregistrement résultat sous forme de texte if (randomPosition == 1) { goodRep = true good = good + 1 savedTxtFile = "D/1/\(targetArrayName[nessai-1])/\(vectorTarget)/ \(stringFromTimeInterval(dureeAnimation))/\(stringFromTimeInterval(tempsReponse))/" } else { savedTxtFile = "G/0/\(targetArrayName[nessai-1])/\(vectorTarget)/ \(stringFromTimeInterval(dureeAnimation))/\(stringFromTimeInterval(tempsReponse))/" } leftButton.hidden = true rightButton.hidden = true } // ---------------------------- leftPress ---------------------------------- @IBAction func leftPress(sender: UIButton) { var endChoice = NSDate() var tempsReponse:NSTimeInterval = endChoice.timeIntervalSinceDate(self.startChoice) leftButton.enabled = false rightButton.enabled = false self.makeAChoice.text = " Laquelle de ces images est apparue plusieurs fois?" // Sélection des images pour choix forcé et disposition aléatoire random1 = Int(arc4random_uniform(5))+5 random2 = Int(arc4random_uniform(5))+5 image1 = getUncachedImage(named:"\(targetArrayName[nessai-1]).jpg")! image2=getUncachedImage(named:"\(leurreArrayName[nessai-1]).jpg")! if (flux1Name[random1] != targetArrayName[nessai-1]) { image3 = flux1[random1] } else {image3 = flux1[random1-1] } image4=flux2[random2] choiceArray = [image1, image2, image3, image4] for var idx = 3; idx > 0; idx-- { var p = arc4random_uniform(UInt32(idx+1)) swap(&choiceArray[idx], &choiceArray[Int(p)]) println(idx) println(p) } choixCible1.image = choiceArray[0] choixCible2.image = choiceArray[1] choixCible3.image = choiceArray[2]& choixCible4.image = choiceArray[3] choix1Button.enabled = true choix2Button.enabled = true choix3Button.enabled = true choix4Button.enabled = true 59

// Enregistrement résultat sous forme de texte if (randomPosition == 0) { goodRep = true good = good + 1 savedTxtFile = "G/1/\(targetArrayName[nessai-1])/\(vectorTarget)/\(stringFromTimeInterval (dureeAnimation))/\(stringFromTimeInterval(tempsReponse))/" } else { savedTxtFile = "D/0/\(targetArrayName[nessai-1])/\(vectorTarget)/\(stringFromTimeInterval (dureeAnimation))/\(stringFromTimeInterval(tempsReponse))/" } leftButton.hidden = true rightButton.hidden = true } // ________________________ bouton identification cible 1 ______________________________ @IBAction func pressChoix1Button(sender: AnyObject) { choixCible1.image = nil choixCible2.image = nil choixCible3.image = nil choixCible4.image = nil choix1Button.enabled = false choix2Button.enabled = false choix3Button.enabled = false choix4Button.enabled = false self.makeAChoice.text = "" // Enregistrement résultats format texte if (choiceArray[0] == image1) { txtToSave = "C\n" if (goodRep == true) { goodTarget = goodTarget + 1 myLabel.text = "Bonne réponse!\nBRAVO" } else { myLabel.text = "Bonne réponse,\nmais n'est ce pas un coup de chance?" } } else { myLabel.text = "Mauvaise réponse" if (choiceArray[0] == image2){ txtToSave = "L/\(leurreArrayName[nessai-1])\n" } else { if (choiceArray[0] == image3) { if (flux1Name[random1] != targetArrayName[nessai-1] ) { txtToSave = "D1/\(flux1Name[random1])\n" } else { txtToSave = "D1/\(flux1Name[random1-1])\n" } } else { txtToSave = "D2/\(flux2Name[random2])\n" } } } savedTxtFile = savedTxtFile.stringByAppendingString(txtToSave) txtFinal = txtFinal.stringByAppendingString(savedTxtFile) // Sauvegarde des résultat SaveResults() // Vérification compteur essai et lancement de l'essai suivant/chgt de bloc/ fin endEssai() if (nessai<35) { constructionFlux() } } 60

// ________________________________ bouton identification cible 2 ______________________________ @IBAction func pressChoix2Button(sender: AnyObject) { choixCible1.image = nil choixCible2.image = nil choixCible3.image = nil choixCible4.image = nil choix1Button.enabled = false choix2Button.enabled = false choix3Button.enabled = false choix4Button.enabled = false self.makeAChoice.text = "" if (choiceArray[1] == image1) { txtToSave = "C\n" if (goodRep == true) { goodTarget = goodTarget + 1 myLabel.text = "Bonne réponse!\nBRAVO" } else { myLabel.text = "Bonne réponse,\nmais n'est ce pas un coup de chance?" } } else { myLabel.text = "Mauvaise réponse" if (choiceArray[1] == image2){ txtToSave = "L/\(leurreArrayName[nessai-1])\n" } else { if (choiceArray[1] == image3) { if (flux1Name[random1] != targetArrayName[nessai-1] ) { txtToSave = "D1/\(flux1Name[random1])\n" } else { txtToSave = "D1/\(flux1Name[random1-1])\n" } } else { txtToSave = "D2/\(flux2Name[random2])\n" } } } savedTxtFile = savedTxtFile.stringByAppendingString(txtToSave) txtFinal = txtFinal.stringByAppendingString(savedTxtFile) SaveResults() endEssai() if (nessai<35) { constructionFlux() } } // _______________________bouton identification cible 3 ______________________________ @IBAction func pressChoix3Button(sender: AnyObject) { choixCible1.image = nil choixCible2.image = nil choixCible3.image = nil choixCible4.image = nil choix1Button.enabled = false choix2Button.enabled = false choix3Button.enabled = false choix4Button.enabled = false self.makeAChoice.text = "" if (choiceArray[2] == image1) { txtToSave = "C\n" if (goodRep == true) { 61

goodTarget = goodTarget + 1 myLabel.text = "Bonne réponse!\nBRAVO" } else { myLabel.text = "Bonne réponse,\nmais n'est ce pas un coup de chance?" } } else { myLabel.text = "Mauvaise réponse" if (choiceArray[2] == image2){ txtToSave = "L/\(leurreArrayName[nessai-1])\n" } else { if (choiceArray[2] == image3) { if (flux1Name[random1] != targetArrayName[nessai-1] ) { txtToSave = "D1/\(flux1Name[random1])\n" } else { txtToSave = "D1/\(flux1Name[random1-1])\n" } } else { txtToSave = "D2/\(flux2Name[random2])\n" } } } savedTxtFile = savedTxtFile.stringByAppendingString(txtToSave) txtFinal = txtFinal.stringByAppendingString(savedTxtFile) SaveResults() endEssai() if (nessai<35) { constructionFlux() } } // ____________________________________ bouton identification cible 4 ______________________________ @IBAction func pressChoix4Button(sender: AnyObject) { choixCible1.image = nil choixCible2.image = nil choixCible3.image = nil choixCible4.image = nil choix1Button.enabled = false choix2Button.enabled = false choix3Button.enabled = false choix4Button.enabled = false self.makeAChoice.text = "" if (choiceArray[3] == image1) { txtToSave = "C\n" if (goodRep == true) { goodTarget = goodTarget + 1 myLabel.text = "Bonne réponse!\nBRAVO" } else { myLabel.text = "Bonne réponse,\nmais n'est ce pas un coup de chance?" } } else { myLabel.text = "Mauvaise réponse" if (choiceArray[3] == image2){ txtToSave = "L/\(leurreArrayName[nessai-1])\n" } else { if (choiceArray[3] == image3) { if (flux1Name[random1] != targetArrayName[nessai-1] ) { txtToSave = "D1/\(flux1Name[random1])\n" } else { txtToSave = "D1/\(flux1Name[random1-1])\n" } } else { txtToSave = "D2/\(flux2Name[random2])\n" } } } 62

savedTxtFile = savedTxtFile.stringByAppendingString(txtToSave) txtFinal = txtFinal.stringByAppendingString(savedTxtFile) SaveResults() endEssai() if (nessai<35) { constructionFlux() } } //------------------------------------endEssai------------------------------------------- func endEssai() { if (nessai == entrainement) { startButton.hidden = true startButton.enabled = false goodTarget = 0 delay(2.0){ self.myLabel.text = " Fin du bloc d'entraînement " self.delay(2.0){ self.myLabel.text = "Appuyer sur START pour commencer l'expérience" self.startButton.hidden = false self.startButton.enabled = true self.homeButton.hidden = false self.homeButton.enabled = true } } delay(5.0) {self.nbloc = self.nbloc+1} } else { if ((nessai - entrainement) % essai == 0 && nessai != entrainement) { if (nbloc == bloc) { self.monScore = Score(score: self.good, identify:self.goodTarget, date:NSDate(), levelSaved:levelSaved, pseudoSaved:pseudoSaved) self.saveData() delay(2.0){ self.myLabel.text = "Fin de l'expérience. \n Merci pour votre participation" self.delay(2.0){ self.myLabel.text = " Appuyez maintenant sur CONTINUER pour accèder à vos résultats et nous les transmettre." self.sendButton.hidden = false self.sendButton.enabled = true self.homeButton.hidden = false self.homeButton.enabled = true } } } else { startButton.hidden = true startButton.enabled = false delay(2.0){ self.myLabel.text = " Fin du bloc \(self.nbloc) " self.delay(2.0){ self.myLabel.text = "Appuyer sur START pour commencer le bloc \(self.nbloc+1)" self.startButton.hidden = false self.startButton.enabled = true self.homeButton.hidden = false self.homeButton.enabled = true 63

} } } delay(5.0) {self.nbloc = self.nbloc+1} } else { startButton.hidden = false startButton.enabled = true self.homeButton.hidden = false self.homeButton.enabled = true } } } // ----------------------- Fonction conversion Time Interval en String ------------------------ func stringFromTimeInterval(interval: NSTimeInterval) -> NSString { var ti = NSInteger(interval) var ms = Int((interval % 1) * 1000 ) var seconds = ti % 60 return NSString(format: "%d.%d",seconds,ms) } // --------------------------------- Fonction retour Menu ------------------------------------- @IBAction func backMenu(sender: AnyObject) { let alertMenu = UIAlertController(title: "Attention", message: "Si vous quittez l'expérience maintenant, vos résultats ne seront pas enregistrés. Etes vous sûrs de vouloir interrompre l'expérience?", preferredStyle: UIAlertControllerStyle.Alert) alertMenu.addAction(UIAlertAction(title: "OK", style: UIAlertActionStyle.Default, handler: { action in let storyboard = UIStoryboard (name: "Main", bundle: nil) let nextViewController = storyboard.instantiateViewControllerWithIdentifier("menu") as! MenuViewController self.navigationController!.pushViewController(nextViewController, animated: true) })) alertMenu.addAction(UIAlertAction(title: "Annuler", style: UIAlertActionStyle.Default, handler:nil)) self.presentViewController(alertMenu, animated: true, completion: nil) } // ------------------------------------ Fonction délai ------------------------------------ func delay(delay:Double, closure:()->()){ // retarder une action dispatch_after( dispatch_time( DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)) ), dispatch_get_main_queue(), closure) } //-----------------------------------------Sauver Résultats------------------------------------ func saveData(){ let path = documentsFolderForSavingFiles.stringByAppendingString(fileSave) 64

var success = false

success = NSKeyedArchiver.archiveRootObject(monScore!, toFile: path) if success { println("saved") } else {println("error saving data") } println(path) } // _________________________ Enregistrement des résultats dans fichier txt ------------------- func SaveResults() { txtFinal.writeToFile(myPath, atomically: true, encoding: NSUTF8StringEncoding, error: nil) DataContainerSingleton.sharedDataContainer.txtResult = txtFinal } // ------------------------------ Méthode chargement images ----------------------------------- func getUncachedImage (named name: String) -> UIImage? { if let imgPath = NSBundle.mainBundle().pathForResource(name, ofType: nil) { return UIImage(contentsOfFile: imgPath) } return nil } } `

65

Annexe 3: Storyboard de l'application (version 1)

Annexe 4: Exemple de f ichier résultats transmis par mail au chercheur

[email protected] adresse mail MARTU/22/F identifiant/âge/genre v1.0/3/05-08-2015_20:01:32/iPad Mini version/niveau/date/device [d8669, d10067, d8793, d9901,..., d10505, d8987, d10781, d8056, d9680,d9972, d8955, d8794, d7750, d11160, d10051] vecteur distracteurs [d8682, d7987, d8049, d7895, d9606, d8743, d8927, d9014, d9830, d9780, d9692, d9432,d9987, d9512, d8331, d8537, d8403, d9364, d9160, d8250, d9296, d8116, d8599, d7754, d7816, d10148, d7692, d9909, d8166, d8830, d7642, d10070, d9092, d9229, d8476] vecteur cibles [d9249, d9626, d9532, d7915, d8186, d10007, d9180, d9316, d8351, d8947, d7712,d7774, d7662, d8007, d8423, d9850, d8270, d8136, d10090, d9384, d8850, d9452, d8069, d8763, d9800, d7836, d8557, d9712, d8619, d9929, d8496, d9112, d10168, d8702, d9034] vecteur leurres G/1/d8682/[5, 10, 16, 22, 25, 28, 34, 40, 46, 51, 54, 57]/6.0/0.732/D2/d9483 réponse côté sujet/vrai(1)ou faux(0)/image cible/vecteur position des cibles/durée de l'animation/ temps de réponse localisation/image réponse choix forcé(C=Cible, D1,2=Distracteur1,2, L=Leurre)/nom image choix D/1/d7987/[6, 11, 14, 19, 25, 29]/3.0/0.631/C G/1/d8049/[5, 9, 12, 17, 21, 26, 31, 37, 43, 49, 52, 58, 64, 68, 73, 79, 84, 87]/9.0/0.533/C ... D/0/d10070/[8, 12, 15, 21, 25, 29, 32, 36, 39, 45, 51, 57, 61, 64, 69, 75, 81, 86, 89]/9.0/0.882/C D/0/d9092/[7, 13, 16, 22, 27, 30, 35, 39]/4.0/0.864/D1/d9585 D/1/d9229/[5, 10, 13, 19, 22, 27, 30, 34, 37, 40, 46, 49, 53, 57]/6.0/0.948/D1/d10474 1/9/7 nombre de personnes autour/concentration/fixation

67

Annexe 5: Histogramme des âges des participants à l 'expérience

0

1

2

3

4

5

18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58

Nom

bre

de p

artic

ipan

ts

Âge

Histogramme des âges

Femmes

Hommes

68

Annexe 6: Condit ions de passage des sujets

Sujet Genre Age Ordre iPad MYLPO F 22 A Air EDWCO H 28 A mini JEAMI F 20 B Air LAUAZ F 20 B mini MARGA F 25 C Air REMMI H 31 C mini CECJU F 28 D Air JAYVI F 27 D mini

MELVA F 22 E Air SOPLA F 20 E mini EVELE F 37 F Air GUIFR H 38 F mini CECFR F 39 A Air SYLGO F 42 A mini ANNGA F 33 B Air CHRLA F 25 B mini BRIMA F 27 C Air PERDE F 35 D mini MORHO F 29 D Air AMIAL F 25 C mini

MANME H 36 E Air CAMCO F 24 E mini MATCR H 25 F Air HADDE F 42 A Air SAMRI H 25 F mini

REMMA H 20 B mini LEASE F 18 B Air FATHA F 37 A mini MARTU F 22 A mini SIMTH H 59 A Air

EMEMA F 26 A Air MAAPI H 24 A Air JERSA H 26 E Air

L�gende ordre de passage A: Facile - Interm�diaire - Difficile B: Difficile - Interm�diaire - Facile C: Interm�diaire - Facile - Difficile D: Interm�diaire - Difficile- Facile E: Facile - Difficile - Interm�diaire

F: Difficile - Facile - Interm�diaire 69

Annexe 7: Performances de localisation et identif ication pour chaque nombre de présentations

70

Annexe 8: Exemple d'images appartenant à chacune des quatre catégories Animaux

Objets

71

Paysages

Textures

72

Annexe 9: Design des f lux de la version 2 de l 'application Nombre d'essais 1 1 3 4 5 8 10 Nombre

de pr�sentations de la cible

0 1 2 4 6 8 10

Images Flux1

Flux2

Flux1

Flux2

Flux1

Flux2

Flux1

Flux2

Flux1

Flux2

Flux1

Flux2

Flux1

Flux2

1 D D D D D D D D D D D D D D 2 D D D D D D D D D D D D D D 3 D D D D D D D D D D D D D D 4 D D D D D D D D D D D D D D 5 D D D D D D D D D D D D D D 6 D D D D D D D C D D D D D C 7 D D D D D C D D D D D D D D 8 D D D D D D D C D D D C D C 9 D D D D D C D D D D D D D D 10 D D D D D D D C D D D C D C 11 D D D D D D D D D C D D D D 12 D D D D D D D C D D D C D C 13 D D D D D D D D D C D D D D 14 D D D C D D D D D D D C D C 15 D D D D D D D D D C D D D D 16 D D D D D D D D D D D C D C 17 D D D D D D D D D C D D D D 18 D D D D D D D D D D D C D C 19 D D D D D D D D D C D D D D 20 D D D D D D D D D D D C D C 21 D D D D D D D D D C D D D D 22 D D D D D D D D D D D C D C 23 D D D D D D D D D D D D D D 24 D D D D D D D D D D D D D C 25 D D D D D D D D D D D D D D 26 D D D D D D D D D D D D D D 27 D D D D D D D D D D D D D D 28 D D D D D D D D D D D D D D 29 D D D D D D D D D D D D D D

73

Annexe 10: Script de la tâche expérimentale dans la version 2 // ViewController central de l'application --->> expérience // ViewController.swift // ProjetRSVP // // Created by Camille on 20/05/2015. // All rights reserved. // import UIKit import Foundation class ViewController: UIViewController { // ---------------- Declaration Outlet storyboard ---------------------------------------------- @IBOutlet weak var imageView1: UIImageView! @IBOutlet weak var imageView2: UIImageView! @IBOutlet weak var imageView: UIImageView! @IBOutlet weak var imageTarget: UIImageView! @IBOutlet weak var choixCible1: UIImageView! @IBOutlet weak var choixCible2: UIImageView! @IBOutlet weak var choixCible3: UIImageView! @IBOutlet weak var choixCible4: UIImageView! @IBOutlet weak var choix1Button: UIButton! @IBOutlet weak var choix2Button: UIButton! @IBOutlet weak var choix3Button: UIButton! @IBOutlet weak var choix4Button: UIButton! @IBOutlet weak var startButton: UIButton! @IBOutlet weak var leftButton: UIButton! @IBOutlet weak var rightButton: UIButton! @IBOutlet weak var myLabel: UILabel! @IBOutlet weak var myLabel2: UILabel! @IBOutlet weak var makeAChoice: UILabel! @IBOutlet weak var homeButton: UIButton! @IBOutlet weak var sendButton: UIButton! // -------------------------- Déclaration variables -------------------------------------------- var timer = NSTimer() var startFlux = NSDate() var tpsAnim = NSTimeInterval() var levelSaved:Int = DataContainerSingleton.sharedDataContainer.level // Variable globale pour le niveau choisi var pseudoSaved: String = DataContainerSingleton.sharedDataContainer.pseudo // variable globale pseudo pour fichier réponse var decal = UInt32() // Variable utilisée pour faire des blocs d'images différents pour chacun des trois niveaux var posMin = 4 // Position minimale de la première cible dans le flux. A paramètrer, possible lecture sur le serveur var entrainement = 5 // Nombre d'essais d'entrainement. Possible lecture sur serveur var essai = 32 // Nombre d'essais dans une session sans compter entrainements. Possible lecture sur serveur var nbloc = 0 // Compteur bloc var nessai = 0 // Compteur essai var m = 0 // Compteur var n = 0 // Compteur var i = 0 // Compteur var freq = Double() // Nbe images/seconde. Possible lecture sur serveur var interTarget = Int() // Nombre de distracteurs entre deux cibles consécutives 74

var nbPresentation = [Int]() // Vecteur contenant le nbe de présentations de la cible pour chaque essai var nbEntrainement = [Int]() // Vecteur contenant le nbe de présentations de la cible pour les essais d'entraînement var distractorArrayName = [String]() // Vecteur contenant le nom des images distracteurs var targetArrayName = [String]() // Vecteur contenant le nom des images cibles var leurreArrayName = [String]() // Vecteur contenant le nom des images leurres var flux1Name = [String]() // Vecteur contenant les noms des images du flux 1 (construit à chaque essai) var flux2Name = [String]() // Vecteur contenant les noms des images du flux 2 (construit à chaque essai) var flux1 = [UIImage]() // Vecteur contenant les images du flux 1 (construit à chaque essai) var flux2 = [UIImage]() // Vecteur contenant les images du flux 2 (construit à chaque essai) var randomNumber = UInt32() // Nombre aléatoire utilisé pour la construction des flux var vectorTarget = [UInt32]() // Vecteur positions des cibles dans le flux var vectorSize = Double() // Nombre d'images dans le flux var randomPosition: UInt32 = 0 // nombre aléatoire utilisé pour ramdomisé côté affichage des cibles var X = UIImageView() // ImagevIew où l'on affiche un flux var Y = UIImageView() // ImagevIew où l'on affiche l'autre flux var dureeAnimation = NSTimeInterval() // Durée d'animation des flux (dépend de la fréquence et du nombre d'images dans le flux) var startChoice = NSDate() // pour calcul temps de réponse var random1 = Int() // nombre aléatoire pour choix distracteur1 à afficher pour choix forcé var random2 = Int() // nombre aléatoire pour choix distracteur2 à afficher pour choix forcé var image1 = UIImage() var image2 = UIImage() var image3 = UIImage() var image4 = UIImage() // images proposées pour le choix forcé var choiceArray = Array<UIImage>() // tableau des images proposées pour le choix forcé var good = 0 // Compteur cibles correctement localisées var goodRep:Bool = false // Booléen pour cible localisée correctement ou non var goodTarget = 0 // Compteur de cibles correctement localisées+identifiées let theFileManager = NSFileManager.defaultManager() // Pour stockage fichier réponse let documentsFolderForSavingFiles = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as! String // Répertoire de stockage var myPath = "" // répertoire stockage var txtToSave: String = "" // Variable pour stocker du texte à ajouter à fichier reponse var txtFinal:String = DataContainerSingleton.sharedDataContainer.mail.stringByAppendingString (DataContainerSingleton.sharedDataContainer.infoSujet) // variable stockage texte var savedTxtFile:String = "" // Variable pour stocker le texte à ajouter au fichier texte à chaque itération var fileName = "" // nom fichier pour enregistrement réponse qui sera envoyer par mail var fileSave = "" // nom fichier pour stockage des scores utilisé ensuite pour afficher les résultats dans l'appli var monScore: Score? // variable de stockages de résultats utiliser pour affichage dans l'appli // Variables utilisées pour lecture de données sur le serveur // var url:NSURL = DataContainerSingleton.sharedDataContainer.URLvalid // var error: NSErrorPointer = nil // var lines = [String]() // var values = [String]() // var xmlVersion = String() 75

// ------------------------------------- Bloquer orientation iPad ----------------------------------- override func supportedInterfaceOrientations() -> Int { return Int(UIInterfaceOrientationMask.LandscapeLeft.rawValue) } override func preferredInterfaceOrientationForPresentation() -> UIInterfaceOrientation { return .LandscapeLeft } // ----------------------------------- Fonction chargement vue ------------------------------------- override func viewDidLoad() { super.viewDidLoad() // Orientation écran let value = UIInterfaceOrientation.LandscapeLeft.rawValue UIDevice.currentDevice().setValue(value, forKey: "orientation") // ------- ne pas afficher de bouton retour ----------------------- self.navigationItem.setHidesBackButton(true, animated:true) // ------------------------------- Lecture des donnée sur le serveur ------------------------------ // // let data = String(contentsOfURL: url, error: error) // let newline = NSCharacterSet.newlineCharacterSet() // var data2 = data!.stringByTrimmingCharactersInSet(newline).enumerateLines // // { line, stop in self.lines.append(line) } // // values = lines[0].componentsSeparatedByString(":") // xmlVersion = values[1] // values = lines[4].componentsSeparatedByString(":") // posMin = UInt32(values[1].toInt()!) // values = lines[5].componentsSeparatedByString(":") // distMin = values[1].toInt()! // values = lines[6].componentsSeparatedByString(":") // distMax = values[1].toInt()! // values = lines[7].componentsSeparatedByString(":") // entrainement = values[1].toInt()! // values = lines[8].componentsSeparatedByString(":") // essai = values[1].toInt()! // values = lines[9].componentsSeparatedByString(":") // bloc = values[1].toInt()! // // if (levelSaved == 1 ) { // values = lines[10].componentsSeparatedByString(":") } // else if (levelSaved == 2){ // values = lines[11].componentsSeparatedByString(":") } // else { values = lines[12].componentsSeparatedByString(":") } // freq = UInt32(values[1].toInt()!) // ----------------------------création des fichiers pour enregistrer les résultats----------------- let date = NSDate() // Convertion NSDate en String var formatter: NSDateFormatter = NSDateFormatter() formatter.dateFormat = "dd-MM-yyyy_HH:mm:ss" let stringDate: String = formatter.stringFromDate(date) let device = UIDevice.currentDevice().modelName txtFinal = txtFinal.stringByAppendingString("\(levelSaved)/\(stringDate)/\(device)\n\n") fileName = "/\(stringDate).txt" fileSave = "/saveResults.plist" myPath = documentsFolderForSavingFiles.stringByAppendingString(fileName) DataContainerSingleton.sharedDataContainer.filePath = fileName 76

// --------------------------- Fréquence ----------------------------------------------------------- if (levelSaved == 1) { freq = 20 interTarget = 1} else {if (levelSaved == 2) { freq = 30 interTarget = 2} else { freq = 40 interTarget = 3} } // ------------------------------- Affichage écran ------------------------------------------------- makeAChoice.text = "Phase d'entraînement" myLabel.text = "Appuyer sur START pour démarrer l'entraînement" // Cacher les boutons réponse sendButton.hidden = true sendButton.enabled = false choix1Button.enabled = false choix2Button.enabled = false choix3Button.enabled = false choix4Button.enabled = false leftButton.hidden = true rightButton.hidden = true leftButton.enabled = false rightButton.enabled = false // -------------- Construction des tableaux UIImages cibles, distracteurs et leurres -------------- // Choix du stock d'images attribué au niveau if (levelSaved==2) { decal = 2400 } if (levelSaved==3) { decal = 4800 } else { decal = 0 } // Sélection des 37 cibles et leurres nécessaires var t = arc4random_uniform(34) + 1 + decal targetArrayName = ["d\(t)"] leurreArrayName = ["d\(t+20)"] for i in 1...36 { t = t + 35 + arc4random_uniform(30) targetArrayName.append("d\(t)") leurreArrayName.append("d\(t+20)") } // Construction vecteur distracteurs for i in (decal+1)...(decal+2400) { if ( targetArrayName[m] == "d\(i)" && m<36 ) { m = m+1 } else { if ( leurreArrayName[n] == "d\(i)" && n<36 ) { n = n+1 } else { if ( targetArrayName[m] != "d\(i)" && leurreArrayName[n] != "d\(i)" ) { distractorArrayName.append("d\(i)") } } } } // Tableau nombre de présentations nbPresentation = [0, 1, 2, 2, 2, 4, 4, 4, 4, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 ] nbEntrainement = [10, 4, 6, 8, 10] 77

// Mélange des tableaux de noms distracteurs for var index = distractorArrayName.count - 1; index > 0; index-- { var j = Int(arc4random_uniform(UInt32( index - 1))) swap(&distractorArrayName[index], &distractorArrayName[j]) } // mélange noms cibles for var index = targetArrayName.count - 1; index > 0; index-- { var j = Int(arc4random_uniform(UInt32( index - 1))) swap(&targetArrayName[index], &targetArrayName[j]) } // mélange noms leurres for var index = leurreArrayName.count - 1; index > 0; index-- { var j = Int(arc4random_uniform(UInt32( index - 1))) swap(&leurreArrayName[index], &leurreArrayName[j]) } // Mélange nbPrésentations flux for var index = nbPresentation.count - 1; index > 0; index-- { var j = Int(arc4random_uniform(UInt32(index+1))) swap(&nbPresentation[index], &nbPresentation[j]) } // Mélange nbEntrainement for var index = nbEntrainement.count - 1; index > 0; index-- { var j = Int(arc4random_uniform(UInt32(index+1))) swap(&nbEntrainement[index], &nbEntrainement[j]) } // Fusion des tableaux nbEntrainement et nbPrésentations nbPresentation = nbEntrainement+nbPresentation // enregistrement des vectaurs images pour le fichier résultat envoyé par mail txtFinal = txtFinal.stringByAppendingString("\(distractorArrayName)\n\(targetArrayName)\n \(leurreArrayName)\n\n") // Appel la fonction de construstion des flux d'images constructionFlux() } // ------------------------------------ Fonction retour menu --------------------------------------- @IBAction func backMenu(sender: AnyObject) { let alertMenu = UIAlertController(title: "Attention", message: "Si vous quittez l'expérience maintenant, vos résultats ne seront pas enregistrés. Etes vous sûrs de vouloir interrompre l'expérience?", preferredStyle: UIAlertControllerStyle.Alert) alertMenu.addAction(UIAlertAction(title: "OK", style: UIAlertActionStyle.Default, handler: { action in let storyboard = UIStoryboard (name: "Main", bundle: nil) let nextViewController = storyboard.instantiateViewControllerWithIdentifier("menu") as! MenuViewController self.navigationController!.pushViewController(nextViewController, animated: true) })) alertMenu.addAction(UIAlertAction(title: "Annuler", style: UIAlertActionStyle.Default, handler:nil)) self.presentViewController(alertMenu, animated: true, completion: nil) } 78

// --------------------------------- Fonction construction des flux d'images ----------------------- func constructionFlux() { vectorTarget.removeAll() flux1.removeAll() flux2.removeAll() flux1Name.removeAll() flux2Name.removeAll() if (nbPresentation[nessai] == 0 ) { vectorTarget=[] vectorSize = 10 while (flux1.count<Int(vectorSize)) { flux1.append(getUncachedImage(named:"\(distractorArrayName[i+1]).jpg")!) flux1Name.append(distractorArrayName[i+1]) i=i+1 flux2.append(getUncachedImage(named:"\(distractorArrayName[i+1]).jpg")!) flux2Name.append(distractorArrayName[i+1]) i=i+1 } } else { vectorSize = 10 + Double(maxElement(nbPresentation)) + Double(((maxElement(nbPresentation)-1)*interTarget)) randomNumber = UInt32(posMin) + arc4random_uniform(UInt32(22- (2*(nbPresentation[nessai]-1)))) vectorTarget.append(randomNumber) if (nbPresentation[nessai] != 1 ) { for i in 1...(nbPresentation[nessai]-1) { vectorTarget.append(vectorTarget[i-1]+UInt32(interTarget))+1 } } var j:Int = 0 while (flux1.count<Int(vectorSize)) { flux1.append(getUncachedImage(named:"\(distractorArrayName[i+1]).jpg")!) flux1Name.append(distractorArrayName[i+1]) i=i+1 flux2.append(getUncachedImage(named:"\(distractorArrayName[i+1]).jpg")!) flux2Name.append(distractorArrayName[i+1]) i=i+1 if (j<vectorTarget.count && UInt32(flux1.count) == vectorTarget[j] ) { flux1.append(getUncachedImage(named:"\(targetArrayName[nessai]).jpg")!) flux1Name.append(targetArrayName[nessai]) flux2.append(getUncachedImage(named:"\(distractorArrayName[i+1]).jpg")!) flux2Name.append(distractorArrayName[i+1]) i=i+1; j=j+1; } } } dureeAnimation = NSTimeInterval(vectorSize/freq) // Ramdomisation coté affichage des cibles 79

var tabloImageView: [UIImageView] = [imageView1,imageView2] randomPosition = arc4random_uniform(2) var randomPositionInt = Int(randomPosition) X = tabloImageView[randomPositionInt] if (randomPosition == 1) { Y = tabloImageView[0] } else { Y = tabloImageView[1] } } // ---------------------------------------- Croix de fixation -------------------------------------- @IBAction func animation(sender: UIButton) { var animCross = [UIImage]() animCross.append(UIImage(named:"cross.jpg")!) delay(1.0){ self.imageView.animationImages = animCross self.imageView.animationRepeatCount = 1 self.imageView.animationDuration = (2 + self.dureeAnimation) self.imageView.startAnimating() } } // ------------------------------------- didReceiveMemoryWarning ----------------------------------- override func didReceiveMemoryWarning() { super.didReceiveMemoryWarning() // Dispose of any resources that can be recreated. } // ---------------------------------------- startAnimation --------------------------------------------------- @IBAction func startAnimation(sender: UIButton) { goodRep = false timer = NSTimer.scheduledTimerWithTimeInterval((dureeAnimation + 3.4), target:self, selector:Selector("makeYourChoice"), userInfo: nil, repeats:false) startButton.hidden = true startButton.enabled = false homeButton.hidden = true homeButton.enabled = false self.myLabel.text = "" makeAChoice.text = "" myLabel2.text = "" imageTarget.image = nil // Lancement du flux après delay delay(3.0){ // self.now = NSDate() self.startFlux = NSDate() self.X.animationImages = self.flux1 self.X.animationRepeatCount=1 self.X.animationDuration = self.dureeAnimation self.X.startAnimating() self.Y.animationImages = self.flux2 self.Y.animationRepeatCount=1 self.Y.animationDuration = self.dureeAnimation self.Y.startAnimating() } } 80

// ----------------------------- Apparition boutons choix côté à la fin de l'animation ------------- func makeYourChoice() { startChoice = NSDate() leftButton.hidden = false rightButton.hidden = false self.leftButton.enabled = true self.rightButton.enabled = true nessai = nessai + 1 self.makeAChoice.text = " De quel côté une image est-elle apparue plusieurs fois?" tpsAnim = startChoice.timeIntervalSinceDate(startFlux) } // ----------------------------- Fonction conversion Time Interval en String ----------------------- func stringFromTimeInterval(interval: NSTimeInterval) -> NSString { var ti = NSInteger(interval) var ms = Int((interval % 1) * 1000 ) var seconds = ti % 60 return NSString(format: "%d.%d",seconds,ms) } // ------------------------------------------------ rightPress ------------------------------------ @IBAction func rightPress(sender: UIButton) { var endChoice = NSDate() var tempsReponse:NSTimeInterval = endChoice.timeIntervalSinceDate(self.startChoice) leftButton.enabled = false rightButton.enabled = false // présentation choix forcé self.makeAChoice.text = " Laquelle de ces images est apparue plusieurs fois?" random1 = Int(arc4random_uniform(5))+2 random2 = Int(arc4random_uniform(5))+2 image1 = getUncachedImage(named:"\(targetArrayName[nessai-1]).jpg")! image2=getUncachedImage(named:"\(leurreArrayName[nessai-1]).jpg")! if (flux1Name[random1] != targetArrayName[nessai-1]) { image3 = flux1[random1] } else {image3 = flux1[random1-1] } image4=flux2[random2] choiceArray = [image1, image2, image3, image4] for var idx = 3; idx > 0; idx-- { var p = arc4random_uniform(UInt32(idx+1)) swap(&choiceArray[idx], &choiceArray[Int(p)]) } choixCible1.image = choiceArray[0] choixCible2.image = choiceArray[1] choixCible3.image = choiceArray[2] choixCible4.image = choiceArray[3] choix1Button.enabled = true choix2Button.enabled = true choix3Button.enabled = true choix4Button.enabled = true // Enregistrement réponse if (randomPosition == 1) { goodRep = true good = good + 1 81

savedTxtFile = "D/1/\(targetArrayName[nessai-1])/\(vectorTarget)/\(nbPresentation[nessai-1])/\(stringFromTimeInterval(tempsReponse))/" } else { savedTxtFile = "G/0/\(targetArrayName[nessai-1])/\(vectorTarget)/\(nbPresentation[nessai-1])/\(stringFromTimeInterval(tempsReponse))/" } leftButton.hidden = true rightButton.hidden = true } // ----------------------------------------------- leftPress --------------------------------------- @IBAction func leftPress(sender: UIButton) { var endChoice = NSDate() var tempsReponse:NSTimeInterval = endChoice.timeIntervalSinceDate(self.startChoice) leftButton.enabled = false rightButton.enabled = false // présentation choix forcé self.makeAChoice.text = " Laquelle de ces images est apparue plusieurs fois?" random1 = Int(arc4random_uniform(5))+2 random2 = Int(arc4random_uniform(5))+2 image1 = getUncachedImage(named:"\(targetArrayName[nessai-1]).jpg")! image2=getUncachedImage(named:"\(leurreArrayName[nessai-1]).jpg")! if (flux1Name[random1] != targetArrayName[nessai-1]) { image3 = flux1[random1] } else {image3 = flux1[random1-1] } image4=flux2[random2] choiceArray = [image1, image2, image3, image4] for var idx = 3; idx > 0; idx-- { var p = arc4random_uniform(UInt32(idx+1)) swap(&choiceArray[idx], &choiceArray[Int(p)]) } choixCible1.image = choiceArray[0] choixCible2.image = choiceArray[1] choixCible3.image = choiceArray[2] choixCible4.image = choiceArray[3] choix1Button.enabled = true choix2Button.enabled = true choix3Button.enabled = true choix4Button.enabled = true // Enregistrement réponse if (randomPosition == 0) { goodRep = true good = good + 1 savedTxtFile = "G/1/\(targetArrayName[nessai-1])/\(vectorTarget)/\(nbPresentation[nessai-1])/\(stringFromTimeInterval(tempsReponse))/" } else { savedTxtFile = "D/0/\(targetArrayName[nessai-1])/\(vectorTarget)/\(nbPresentation[nessai-1])/\(stringFromTimeInterval(tempsReponse))/" } leftButton.hidden = true rightButton.hidden = true } 82

//------------------------- Enregistrement des résultats dans fichier txt ------------------------- func SaveResults() { txtFinal.writeToFile(myPath, atomically: true, encoding: NSUTF8StringEncoding, error: nil) DataContainerSingleton.sharedDataContainer.txtResult = txtFinal //Vérif contenu fichier données enregistrées // let infoSaved:String = String(contentsOfFile: pathToTheFile, encoding: NSUTF8StringEncoding, error: nil)! // println(infoSaved) } // __________________________ Bouton identification cible 1 _______________________________________ @IBAction func pressChoix1Button(sender: AnyObject) { choix1Button.enabled = false choix2Button.enabled = false choix3Button.enabled = false choix4Button.enabled = false if choiceArray[0]==image1 { choixCible1.image = getUncachedImage(named:"vrai.png")} else { choixCible1.image = getUncachedImage(named:"faux.png") } self.makeAChoice.text = "" delay(0.2) { self.choixCible1.image = nil self.choixCible2.image = nil self.choixCible3.image = nil self.choixCible4.image = nil self.myLabel2.text = "Cette image est apparue \(self.nbPresentation[self.nessai-1]) fois" self.imageTarget.image = self.image1 if (self.choiceArray[0] == self.image1) { self.txtToSave = "C\n" if (self.goodRep == true) { self.goodTarget = self.goodTarget + 1 self.makeAChoice.text = "Bonne réponse!\nBRAVO" } else { self.makeAChoice.text = "Bonne réponse,\nmais n'est-ce pas un coup de chance?" } } else { self.makeAChoice.text = "Mauvaise réponse" if (self.choiceArray[0] == self.image2){ self.txtToSave = "L/\(self.leurreArrayName[self.nessai-1])\n" } else { if (self.choiceArray[0] == self.image3) { if (self.flux1Name[self.random1] != self.targetArrayName[self.nessai-1] ) { self.txtToSave = "D1/\(self.flux1Name[self.random1])\n" } else { self.txtToSave = "D1/\(self.flux1Name[self.random1-1])\n" } } else { self.txtToSave = "D2/\(self.flux2Name[self.random2])\n" } } } self.savedTxtFile = self.savedTxtFile.stringByAppendingString(self.txtToSave) self.txtFinal = self.txtFinal.stringByAppendingString(self.savedTxtFile) self.SaveResults() self.endEssai() if (self.nessai<37) { self.constructionFlux() } } } 83

// ____________________________ Bouton identification cible 2 ______________________________________ @IBAction func pressChoix2Button(sender: AnyObject) { choix1Button.enabled = false choix2Button.enabled = false choix3Button.enabled = false choix4Button.enabled = false if choiceArray[1]==image1 { choixCible2.image = getUncachedImage(named:"vrai.png")} else { choixCible2.image = getUncachedImage(named:"faux.png") } self.makeAChoice.text = "" delay(0.2) { self.choixCible1.image = nil self.choixCible2.image = nil self.choixCible3.image = nil self.choixCible4.image = nil self.myLabel2.text = "Cette image est apparue \(self.nbPresentation[self.nessai-1]) fois" self.imageTarget.image = self.image1 if (self.choiceArray[1] == self.image1) { self.txtToSave = "C\n" if (self.goodRep == true) { self.goodTarget = self.goodTarget + 1 self.makeAChoice.text = "Bonne réponse!\nBRAVO" } else { self.makeAChoice.text = "Bonne réponse,\nmais n'est-ce pas un coup de chance?" } } else { self.makeAChoice.text = "Mauvaise réponse" if (self.choiceArray[1] == self.image2){ self.txtToSave = "L/\(self.leurreArrayName[self.nessai-1])\n" } else { if (self.choiceArray[1] == self.image3) { if (self.flux1Name[self.random1] != self.targetArrayName[self.nessai-1] ) { self.txtToSave = "D1/\(self.flux1Name[self.random1])\n" } else { self.txtToSave = "D1/\(self.flux1Name[self.random1-1])\n" } } else { self.txtToSave = "D2/\(self.flux2Name[self.random2])\n" } } } self.savedTxtFile = self.savedTxtFile.stringByAppendingString(self.txtToSave) self.txtFinal = self.txtFinal.stringByAppendingString(self.savedTxtFile) self.SaveResults() self.endEssai() if (self.nessai<37) { self.constructionFlux() } } } // ____________________ Bouton identification cible 3 ______________________________________________ @IBAction func pressChoix3Button(sender: AnyObject) { choix1Button.enabled = false choix2Button.enabled = false choix3Button.enabled = false choix4Button.enabled = false if choiceArray[2]==image1 { choixCible3.image = getUncachedImage(named:"vrai.png")} else { choixCible3.image = getUncachedImage(named:"faux.png") } self.makeAChoice.text = "" delay(0.2) { self.choixCible1.image = nil 84

self.choixCible2.image = nil self.choixCible3.image = nil self.choixCible4.image = nil self.myLabel2.text = "Cette image est apparue \(self.nbPresentation[self.nessai-1]) fois" self.imageTarget.image = self.image1 if (self.choiceArray[2] == self.image1) { self.txtToSave = "C\n" if (self.goodRep == true) { self.goodTarget = self.goodTarget + 1 self.makeAChoice.text = "Bonne réponse!\nBRAVO" } else { self.makeAChoice.text = "Bonne réponse,\nmais n'est-ce pas un coup de chance?" } } else { self.makeAChoice.text = "Mauvaise réponse" if (self.choiceArray[2] == self.image2){ self.txtToSave = "L/\(self.leurreArrayName[self.nessai-1])\n" } else { if (self.choiceArray[2] == self.image3) { if (self.flux1Name[self.random1] != self.targetArrayName[self.nessai-1] ) { self.txtToSave = "D1/\(self.flux1Name[self.random1])\n" } else { self.txtToSave = "D1/\(self.flux1Name[self.random1-1])\n" } } else { self.txtToSave = "D2/\(self.flux2Name[self.random2])\n" } } } self.savedTxtFile = self.savedTxtFile.stringByAppendingString(self.txtToSave) self.txtFinal = self.txtFinal.stringByAppendingString(self.savedTxtFile) self.SaveResults() self.endEssai() if (self.nessai<37) { self.constructionFlux() } } } // _____________________ Bouton identification cible 4 ___________________________________________ @IBAction func pressChoix4Button(sender: AnyObject) { choix1Button.enabled = false choix2Button.enabled = false choix3Button.enabled = false choix4Button.enabled = false if choiceArray[3]==image1 { choixCible4.image = getUncachedImage(named:"vrai.png")} else { choixCible4.image = getUncachedImage(named:"faux.png") } self.makeAChoice.text = "" delay(0.2) { self.choixCible1.image = nil self.choixCible2.image = nil self.choixCible3.image = nil self.choixCible4.image = nil self.myLabel2.text = "Cette image est apparue \(self.nbPresentation[self.nessai-1]) fois" self.imageTarget.image = self.image1 if (self.choiceArray[3] == self.image1) { self.txtToSave = "C\n" if (self.goodRep == true) { self.goodTarget = self.goodTarget + 1 85

self.makeAChoice.text = "Bonne réponse!\nBRAVO" } else { self.makeAChoice.text = "Bonne réponse,\nmais n'est-ce pas un coup de chance?" } } else { self.makeAChoice.text = "Mauvaise réponse" if (self.choiceArray[3] == self.image2){ self.txtToSave = "L/\(self.leurreArrayName[self.nessai-1])\n" } else { if (self.choiceArray[3] == self.image3) { if (self.flux1Name[self.random1] != self.targetArrayName[self.nessai-1] ) { self.txtToSave = "D1/\(self.flux1Name[self.random1])\n" } else { self.txtToSave = "D1/\(self.flux1Name[self.random1-1])\n" } } else { self.txtToSave = "D2/\(self.flux2Name[self.random2])\n" } } } self.savedTxtFile = self.savedTxtFile.stringByAppendingString(self.txtToSave) self.txtFinal = self.txtFinal.stringByAppendingString(self.savedTxtFile) self.SaveResults() self.endEssai() if (self.nessai<37) { self.constructionFlux() } } } // --------------------------- Fonction nouvel essai ----------------------------------------------- func endEssai() { if (nessai == entrainement) { startButton.hidden = true startButton.enabled = false goodTarget = 0 delay(2.0){ self.makeAChoice.text = "" self.imageTarget.image = nil self.myLabel2.text = "" self.myLabel.text = " Fin du bloc d'entraînement " self.delay(2.0){ self.myLabel.text = "Appuyer sur START pour commencer l'expérience" self.startButton.hidden = false self.startButton.enabled = true self.homeButton.hidden = false self.homeButton.enabled = true } } delay(5.0) {self.nbloc = self.nbloc+1} } else { if (nessai == 37) { self.monScore = Score(score: self.good, identify:self.goodTarget, date:NSDate(), levelSaved:levelSaved, pseudoSaved:pseudoSaved) self.saveData() delay(2.0){ self.makeAChoice.text = "" self.imageTarget.image = nil self.myLabel2.text = "" self.myLabel.text = "Fin de l'expérience. \n Merci pour votre participation" self.delay(2.0){ self.myLabel.text = " Appuyez maintenant sur CONTINUER pour accèder à vos résultats et nous les transmettre." self.sendButton.hidden = false self.sendButton.enabled = true self.homeButton.hidden = false 86

self.homeButton.enabled = true } } } else { startButton.hidden = false startButton.enabled = true self.homeButton.hidden = false self.homeButton.enabled = true } } } // -------------------------------------------- Fonction délai ------------------------------------- func delay(delay:Double, closure:()->()){ dispatch_after( dispatch_time( DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)) ), dispatch_get_main_queue(), closure) } //---------------------------------------------Sauver Résultats------------------------------------- func saveData(){ let path = documentsFolderForSavingFiles.stringByAppendingString(fileSave) var success = false success = NSKeyedArchiver.archiveRootObject(monScore!, toFile: path) if success { println("saved") } else {println("error saving data") } println(path) } // ----------------------------------- Méthode chargement images ----------------------------------- func getUncachedImage (named name: String) -> UIImage? { if let imgPath = NSBundle.mainBundle().pathForResource(name, ofType: nil) { return UIImage(contentsOfFile: imgPath) } return nil } }

87

RAPPORT DE STAGE DE FIN D’ÉTUDES - Centrale Marseille · 2015-12-13 · RAPPORT DE STAGE DE FIN...

Documents

Transcript of RAPPORT DE STAGE DE FIN D’ÉTUDES - Centrale Marseille · 2015-12-13 · RAPPORT DE STAGE DE FIN...