コード例 #1
0
        private EEGDataListener GetTrialDataListener(out BlockingQueue <IArrayView <EEGDataEntry> > trialQueue)
        {
            var entryList = new List <EEGDataEntry>();
            var queue     = new BlockingQueue <IArrayView <EEGDataEntry> >();

            trialQueue = queue;

            var invoker = new SingleThreadedInvoker();

            return(new EEGDataListener(invoker,
                                       null,
                                       entries =>
            {
                foreach (var entry in entries)
                {
                    // got a new marker, so flush!
                    if (entryList.Count > 0 && entry.Marker != entryList[0].Marker)
                    {
                        queue.Enqueue(entryList.AsIArray());
                        entryList = new List <EEGDataEntry>(entryList.Count);
                    }

                    // save stimulus entries
                    if (entry.HasStimulusMarker())
                    {
                        entryList.Add(entry);
                    }
                }
            },
                                       null,
                                       () => invoker.Dispose()));
        }
コード例 #2
0
        private EEGDataListener GetRawDataRecordingListener()
        {
            if (!this.Settings.SaveRawData)
            {
                return(null);
            }

            StreamWriter writer;

            try
            {
                writer = new StreamWriter(
                    Path.Combine(this.Settings.OutputFolder, GetFileName(RAW_DATA_BASE_NAME, this.startTime, GUIUtils.Strings.CSV_EXTENSION)),
                    false);
            }
            catch (Exception)
            {
                GUIUtils.Alert("Failed to save raw data to " + this.Settings.OutputFolder, MessageBoxIcon.Warning);
                return(null);
            }

            var invoker = new SingleThreadedInvoker();

            return(new EEGDataListener(invoker,
                                       null,
                                       data =>
            {
                try { writer.WriteLine(data.ConcatToString(Environment.NewLine)); }
                catch (Exception) { }
            },
                                       null,
                                       () => { writer.Dispose(); invoker.Dispose(); }));
        }
コード例 #3
0
        /// <summary>
        /// The enumerator implementation
        /// </summary>
        public override IEnumerator <View> GetEnumerator()
        {
            IViewResult result;

            using (var logWriter = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "compexp_log_" + settings.SubjectName + DateTime.Now.ToString("MM dd yyyy H mm ss") + ".txt")))
                using (var dataWriter = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "compexp_" + settings.SubjectName + DateTime.Now.ToString("MM dd yyyy H mm ss") + ".csv")))
                {
                    for (int i = 0; i < 2; i++)
                    {
                        yield return(new ChoiceView(new string[]
                        {
                            "Ready for Study Phase"
                        }, out result));

                        //Present half the stimuli for study
                        for (int j = 0 + i * (presentation.Count / 2); j < (presentation.Count / 2) * (i + 1); j++)
                        {
                            yield return(new TextView(presentation[j], this.settings.PresentationTime, GUIUtils.Constants.DISPLAY_FONT_LARGE));

                            yield return(new RestView(this.settings.RestTime));
                        }

                        //Begin the practice phase
                        yield return(new ChoiceView(new string[]
                        {
                            "Start EEG Recording"
                        }, out result)
                        {
                            Text = "Click When Ready"
                        });

                        var connected = true; // assume it's connected
                        using (var invoker = new SingleThreadedInvoker())
                            using (var connectionListener = new EEGDataListener(invoker, s => connected = true, null, s => connected = false))
                            {
                                // listen for a broken connection
                                this.dataSource.AddListener(connectionListener);
                                foreach (var view in this.GetViews(invoker, logWriter, dataWriter, i))
                                {
                                    if (connected)
                                    {
                                        yield return(view);
                                    }
                                    else
                                    {
                                        GUIUtils.Alert("Lost connection to headset!");
                                        break;
                                    }
                                }

                                this.dataSource.RemoveListener(connectionListener);
                            }
                    }
                }
        }
コード例 #4
0
        /// <summary>
        /// Yields the experiment as a sequence of views
        /// </summary>
        public override IEnumerator <View> GetEnumerator()
        {
            // wait to begin
            yield return(new ChoiceView(new string[] { "Click anywhere to begin" }));

            var connected = new VolatileBool(true); // assume it's connected

            using (var invoker = new SingleThreadedInvoker())
                using (var connectionListener = new EEGDataListener(invoker, s => connected.value = true, null, s => connected.value = false))
                    using (var logger = this.LogExperimentAndGetLogger()) // log the experiment
                        using (var trialLogger = this.GetTrialWriter())   // logs each trial
                        {
                            // create the runtime
                            var runtime = new Runtime(this)
                            {
                                Classifiers = this.ClassificationSchemes.Select(cs => new ClassifierManager(cs)).ToIArray(),
                                Logger      = logger,
                                TrialLogger = trialLogger,
                            };

                            // listen for a broken connection
                            this.DataSource.AddListener(connectionListener);

                            foreach (var view in this.GetViews(runtime))
                            {
                                if (connected.value)
                                {
                                    yield return(view);
                                }
                                else
                                {
                                    GUIUtils.Alert(runtime.LogLine("Lost connection to headset!"));
                                    break;
                                }
                            }

                            this.DataSource.RemoveListener(connectionListener);
                        }
        }
コード例 #5
0
        public static void TestInvoker()
        {
            var          range  = Arrays.Range(0, 1, 100);
            var          list   = new List <int>();
            IAsyncResult result = null;

            using (var sti = new SingleThreadedInvoker())
            {
                foreach (int i in range)
                {
                    int j = i;
                    if (j % 2 == 0)
                    {
                        result = sti.BeginInvoke(new Action(() =>
                        {
                            list.Add(j);
                        }), new object[0]);
                    }
                    else
                    {
                        sti.Invoke(new Action(() =>
                        {
                            list.Add(j);
                        }), new object[0]);
                    }
                }

                // wait for all to finish
                sti.EndInvoke(result);
            }

            if (!list.SequenceEqual(range))
            {
                throw new Exception("SingleThreadedInvoker failed!");
            }
        }
コード例 #6
0
        /// <summary>
        /// The enumerator implementation
        /// </summary>
        public override IEnumerator <View> GetEnumerator()
        {
            IViewResult result;
            Random      numgen = new Random();
            int         a, b;
            RandomizedQueue <string> pres     = new RandomizedQueue <string>();
            RandomizedQueue <string> usedPres = new RandomizedQueue <string>();

            pres.AddRange(presentation);
            using (var logWriter = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "krmon_log_" + settings.SubjectName + "_" + DateTime.Now.ToString("MM dd yyyy H mm ss") + ".txt")))
                using (var anslog = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "krmon_anslog_" + settings.SubjectName + "_" + DateTime.Now.ToString("MM dd yyyy H mm ss") + ".txt")))
                    using (var dataWriter = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "krmon_data_" + settings.SubjectName + "_" + DateTime.Now.ToString("MM dd yyyy H mm ss") + ".csv")))
                    {
                        //Alternating Study and Test Phases
                        for (int i = 0; i < settings.NumRounds; i++)
                        {
                            yield return(new ChoiceView(new string[]
                            {
                                "Start Study Phase"
                            }, out result)
                            {
                                Text = "Click When Ready"
                            });

                            while (pres.Count > 0)
                            {
                                var stimulus = pres.RemoveRandom();
                                yield return(new TextView(stimulus, this.settings.PresentationTime, GUIUtils.Constants.DISPLAY_FONT_LARGE));

                                yield return(new RestView(this.settings.RestTime));

                                usedPres.Add(stimulus);
                            }
                            pres.AddRange(usedPres);
                            usedPres.Clear();

                            a = numgen.Next(4, 13);
                            b = numgen.Next(4, 13);

                            yield return(new VocabView(string.Format("{0} x {1} = {2}", a, b, a * b), "Verify", settings.DisplayTime, settings.DelayTime, true, anslog, out result));

                            yield return(new ChoiceView(new string[]
                            {
                                "Start Test Phase"
                            }, out result)
                            {
                                Text = "Click When Ready"
                            });

                            var connected = true; // assume it's connected
                            using (var invoker = new SingleThreadedInvoker())
                                using (var connectionListener = new EEGDataListener(invoker, s => connected = true, null, s => connected = false))
                                {
                                    // listen for a broken connection
                                    this.dataSource.AddListener(connectionListener);
                                    foreach (var view in this.GetViews(invoker, anslog, logWriter, dataWriter, i, pres))
                                    {
                                        if (connected)
                                        {
                                            yield return(view);
                                        }
                                        else
                                        {
                                            GUIUtils.Alert("Lost connection to headset!");
                                            break;
                                        }
                                    }

                                    this.dataSource.RemoveListener(connectionListener);
                                }
                        }
                    }
        }
コード例 #7
0
        /// <summary>
        /// The enumerator implementation
        /// </summary>
        public override IEnumerator <View> GetEnumerator()
        {
            IViewResult result;
            Random      numgen = new Random();
            RandomizedQueue <StudyTestPair> study = new RandomizedQueue <StudyTestPair>();
            RandomizedQueue <StudyTestPair> quiz  = new RandomizedQueue <StudyTestPair>();
            RandomizedQueue <StudyTestPair> done  = new RandomizedQueue <StudyTestPair>();
            string filename = "adapt_data_" + settings.SubjectName + "_" + DateTime.Now.ToString("MM dd yyyy H mm ss") + ".csv";

            using (var logWriter = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "adapt_log_" + settings.SubjectName + "_" + DateTime.Now.ToString("MM dd yyyy H mm ss") + ".txt")))
                //If using MATLAB reference, the datawriter path must match the location of your MATLAB code
                using (var dataWriter = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), filename)))
                {
                    yield return(new ChoiceView(new string[]
                    {
                        "Ready for Training Study Phase"
                    }, out result));

                    //Present competition stimuli for study
                    for (int j = 0; j < presentation.Count; j++)
                    {
                        yield return(new TextView(presentation[j], this.settings.PresentationTime, GUIUtils.Constants.DISPLAY_FONT_LARGE));

                        yield return(new RestView(this.settings.RestTime));
                    }

                    //Begin the practice phase
                    yield return(new ChoiceView(new string[]
                    {
                        "Start Training EEG Recording"
                    }, out result)
                    {
                        Text = "Click When Ready"
                    });

                    var compconnected = true; // assume it's connected
                    using (var compinvoker = new SingleThreadedInvoker())
                        using (var compconnectionListener = new EEGDataListener(compinvoker, s => compconnected = true, null, s => compconnected = false))
                        {
                            // listen for a broken connection
                            this.dataSource.AddListener(compconnectionListener);
                            foreach (var view in this.GetCompViews(compinvoker, logWriter, dataWriter))
                            {
                                if (compconnected)
                                {
                                    yield return(view);
                                }
                                else
                                {
                                    GUIUtils.Alert("Lost connection to headset!");
                                    break;
                                }
                            }

                            this.dataSource.RemoveListener(compconnectionListener);
                        }

                    //Check that the person has sufficient training data
                    if (numArt1 > 24 || numArt2 > 24)
                    {
                        yield return(new TextView("Error: Weeping Angel", settings.InstructionTime, GUIUtils.Constants.DISPLAY_FONT_LARGE));
                    }

                    //MATLAB REFERENCE
                    //matlab.Execute("cd c:\\Users\\Nicole\\Documents\\Matlab\\Thesis\\Adapt");
                    //matlab.Execute("classifier = wekacomptrain('"+ filename + "');");

                    yield return(new ChoiceView(new string[]
                    {
                        "Start Study Phase"
                    }, out result)
                    {
                        Text = "Click When Ready"
                    });

                    while (pres.Count > 0)
                    {
                        var stimulus = pres.RemoveRandom();
                        yield return(new TextView(stimulus.test + "\n" + stimulus.answer, this.settings.PresentationTime, GUIUtils.Constants.DISPLAY_FONT_LARGE));

                        yield return(new RestView(this.settings.RestTime));

                        quiz.Add(stimulus);
                    }

                    yield return(new ChoiceView(new string[]
                    {
                        "Start Test Phase"
                    }, out result)
                    {
                        Text = "Click When Ready"
                    });

                    var connected = true; // assume it's connected
                    using (var invoker = new SingleThreadedInvoker())
                        using (var connectionListener = new EEGDataListener(invoker, s => connected = true, null, s => connected = false))
                        {
                            // listen for a broken connection
                            this.dataSource.AddListener(connectionListener);
                            foreach (var view in this.GetViews(invoker, logWriter, dataWriter, study, quiz, done, numgen))
                            {
                                if (connected)
                                {
                                    yield return(view);
                                }
                                else
                                {
                                    GUIUtils.Alert("Lost connection to headset!");
                                    break;
                                }
                            }

                            this.dataSource.RemoveListener(connectionListener);
                        }
                }
        }
コード例 #8
0
        /// <summary>
        /// The enumerator implementation
        /// </summary>
        public override IEnumerator <View> GetEnumerator()
        {
            IViewResult result;


            yield return(new ChoiceView(new string[]
            {
                "Start Training Phase"
            }, out result)
            {
                Text = "Click When Ready"
            });

            for (int j = 0; j < comp.Count; j++)
            {
                yield return(new TextView(comp[j], settings.PresentationTime, GUIUtils.Constants.DISPLAY_FONT_LARGE));

                yield return(new RestView(settings.RestTime));
            }
            yield return(new ChoiceView(new string[]
            {
                "Begin Testing"
            }, out result)
            {
                Text = "Click When Ready"
            });

            //Display each block of stimuli
            for (int j = 0; j < (settings.NumBlocks * 2); j++)
            {
                int limit = blocks[j].Count;
                for (int k = 0; k < limit; k++)
                {
                    //Rest
                    yield return(new RestView(this.settings.BlinkTime));

                    //Fixate
                    yield return(new FixationView(this.settings.FixationTime));

                    var stimulus = blocks[j].RemoveRandom();
                    //Generate stimulus view
                    yield return(new TextView(stimulus, settings.PresentationTime, GUIUtils.Constants.DISPLAY_FONT_LARGE));

                    yield return(new TextView(stimulus + "*", settings.PresentationTime / 2, GUIUtils.Constants.DISPLAY_FONT_LARGE));
                }
                yield return(new ChoiceView(new string[]
                {
                    "Ready for next block"
                }, out result));
            }

            RandomizedQueue <string>        pres      = new RandomizedQueue <string>();
            RandomizedQueue <string>        usedPres  = new RandomizedQueue <string>();
            RandomizedQueue <StudyTestPair> studySoon = new RandomizedQueue <StudyTestPair>();
            RandomizedQueue <StudyTestPair> testSoon  = new RandomizedQueue <StudyTestPair>();
            RandomizedQueue <StudyTestPair> testLate  = new RandomizedQueue <StudyTestPair>();

            pres.AddRange(presentation);
            testSoon.AddRange(stp);
            yield return(new ChoiceView(new string[]
            {
                "Start Initial Study Phase"
            }, out result)
            {
                Text = "Click When Ready"
            });

            while (pres.Count > 0)
            {
                var stimulus = pres.RemoveRandom();
                yield return(new TextView(stimulus, this.settings.PresentationTime, GUIUtils.Constants.DISPLAY_FONT_LARGE));

                yield return(new RestView(this.settings.RestTime));

                usedPres.Add(stimulus);
            }
            pres.AddRange(usedPres);
            using (var logWriterV = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "userctrl_logv_" + settings.SubjectName + "_" + DateTime.Now.ToString("MM dd yyyy H mm ss") + ".txt")))
                using (var logWriter = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "userctrl_log_" + settings.SubjectName + "_" + DateTime.Now.ToString("MM dd yyyy H mm ss") + ".csv")))
                {
                    yield return(new ChoiceView(new string[]
                    {
                        "Start Practice Phase"
                    }, out result)
                    {
                        Text = "Click When Ready"
                    });


                    using (var invoker = new SingleThreadedInvoker())
                    {
                        foreach (var view in this.GetViews(invoker, logWriterV, logWriter,
                                                           studySoon, testSoon, testLate))
                        {
                            yield return(view);
                        }
                    }
                }
        }