/* メソッド ****************************************************************/
        /// <summary>
        /// コンストラクタ生成時に渡された情報に従って特徴ベクトル生成器を構成します
        /// </summary>
        /// <param name="reader">音源ファイルを開いた状態のWaveReaderオブジェクト<para>情報取得に利用します。</para></param>
        private void SetGenerator(WaveReader reader)
        {
            IFeatureGenerator generator = null;
            var startupDir = System.Windows.Forms.Application.StartupPath;
            var fname      = startupDir + @"\" + "filter.txt";

            switch (this.id)
            {
            case UnitMember.KMCustomUnit1c1d:
                MinimumCondition condition1 = new MinimumCondition(50);
                generator = new FeatureGenerator <KMCustomUnit1c1d>(condition1, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname);    // 特徴ベクトル生成器のインスタンスを作る
                break;

            case UnitMember.KMCustomUnit2c1d:
                MinimumCondition condition2 = new MinimumCondition(50);
                generator = new FeatureGenerator <KMCustomUnit2c1d>(condition2, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname);    // 特徴ベクトル生成器のインスタンスを作る
                break;

            case UnitMember.KMCustomUnit2c1dver2:
                MinimumCondition condition3 = new MinimumCondition(50);
                generator = new FeatureGenerator <KMCustomUnit2c1dver2>(condition3, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname);    // 特徴ベクトル生成器のインスタンスを作る
                break;

            case UnitMember.KMCustomUnit3c1d:
                MinimumCondition condition4 = new MinimumCondition(5);
                generator = new FeatureGenerator <KMCustomUnit3c1d>(condition4, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname);    // 特徴ベクトル生成器のインスタンスを作る
                break;
            }
            this._generator = generator;

            return;
        }
        public void TestCustom()
        {
            var featureGenerators = new IFeatureGenerator[] {
                new BagOfWordsFeatureGenerator(),
                new NGramFeatureGenerator(),
                new NGramFeatureGenerator(2, 3)
            };
            var factory = new DocumentCategorizerFactory(SimpleTokenizer.Instance, featureGenerators);
            var model   = Train(factory);

            Assert.NotNull(model);

            using (var data = new MemoryStream()) {
                model.Serialize(new UnclosableStream(data));

                data.Seek(0, SeekOrigin.Begin);

                var deserialized = new DocumentCategorizerModel(data);

                Assert.That(deserialized, Is.Not.Null);
                Assert.That(deserialized.Factory, Is.Not.Null);

                Assert.That(deserialized.Factory.FeatureGenerators.Length, Is.EqualTo(3));
                Assert.That(deserialized.Factory.FeatureGenerators[0], Is.InstanceOf <BagOfWordsFeatureGenerator>());
                Assert.That(deserialized.Factory.FeatureGenerators[1], Is.InstanceOf <NGramFeatureGenerator>());
                Assert.That(deserialized.Factory.FeatureGenerators[2], Is.InstanceOf <NGramFeatureGenerator>());

                Assert.That(deserialized.Factory.Tokenizer, Is.InstanceOf <SimpleTokenizer>());
            }
        }
        public void TestCustom() {
            var featureGenerators = new IFeatureGenerator[] {
                new BagOfWordsFeatureGenerator(),
                new NGramFeatureGenerator()
            };
            var factory = new DocumentCategorizerFactory(SimpleTokenizer.Instance, featureGenerators);
            var model = Train(factory);

            Assert.NotNull(model);

            using (var data = new MemoryStream()) {
                model.Serialize(new UnclosableStream(data));

                data.Seek(0, SeekOrigin.Begin);

                var deserialized = new DocumentCategorizerModel(data);

                Assert.NotNull(deserialized);
                Assert.NotNull(deserialized.Factory);

                Assert.AreEqual(2, deserialized.Factory.FeatureGenerators.Length);
                Assert.AreEqual(typeof (BagOfWordsFeatureGenerator), deserialized.Factory.FeatureGenerators[0].GetType());
                Assert.AreEqual(typeof (NGramFeatureGenerator), deserialized.Factory.FeatureGenerators[1].GetType());

                Assert.AreEqual(typeof (SimpleTokenizer), deserialized.Factory.Tokenizer.GetType());
            }
        }
Ejemplo n.º 4
0
        public ClassifyForm(IFeatureGenerator fg)
        {
            InitializeComponent();

            this.fg    = fg;
            fg.Values += new ChangedFeaturesEventHandler(fg_Values);

            listBoxModels.SelectedIndex = -1;

            AsyncWorkerLoadModels = new BackgroundWorker();
            AsyncWorkerLoadModels.WorkerReportsProgress      = true;
            AsyncWorkerLoadModels.WorkerSupportsCancellation = true;
            AsyncWorkerLoadModels.RunWorkerCompleted        += new RunWorkerCompletedEventHandler(AsyncWorkerLoadModels_RunWorkerCompleted);
            AsyncWorkerLoadModels.DoWork += new DoWorkEventHandler(AsyncWorkerLoadModels_DoWork);

            toolStripStatusLabel1.Text = "Loading models. Please wait...";
            ms = new ModelStorage();
            AsyncWorkerLoadModels.RunWorkerAsync();

            AsyncWorkerProcess = new BackgroundWorker();
            AsyncWorkerProcess.WorkerReportsProgress      = true;
            AsyncWorkerProcess.WorkerSupportsCancellation = true;
            AsyncWorkerProcess.ProgressChanged           += new ProgressChangedEventHandler(AsyncWorkerProcess_ProgressChanged);
            AsyncWorkerProcess.DoWork             += new DoWorkEventHandler(AsyncWorkerProcess_DoWork);
            AsyncWorkerProcess.RunWorkerCompleted += new RunWorkerCompletedEventHandler(AsyncWorkerProcess_RunWorkerCompleted);

            this.FormClosing += new FormClosingEventHandler(ClassifyForm_FormClosing);
            if (fg is OpenVibeFeatureGenerator)
            {
                listBoxResult.Items.Insert(0, "You are required to wait until you see: \"Initialization took xxxxx ms\" in OpenVibe.");
            }
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Runs the donut.
        /// </summary>
        /// <param name="donut"></param>
        /// <param name="getFeatureGenerator"></param>
        /// <returns></returns>
        public async Task <IHarvesterResult> Run(TDonut donut, IFeatureGenerator <TData> getFeatureGenerator)
        {
            var integration = donut.Context.Integration;
            //Create our destination block
            var donutBlock          = donut.CreateDataflowBlock(getFeatureGenerator);
            var dataProcessingBlock = donutBlock.FlowBlock;

            _featuresBlock = donutBlock.FeaturePropagator;

            var insertCreator = new TransformBlock <FeaturesWrapper <TData>, BsonDocument>((x) =>
            {
                var rawFeatures      = new BsonDocument();
                var featuresDocument = new IntegratedDocument(rawFeatures);
                //add some cleanup, or feature document definition, because right now the original document is used
                //either clean  it up or create a new one with just the features.
                //if (doc.Document.Value.Contains("events")) doc.Document.Value.Remove("events");
                //if (doc.Document.Value.Contains("browsing_statistics")) doc.Document.Value.Remove("browsing_statistics");
                foreach (var featurePair in x.Features)
                {
                    var name = featurePair.Key;
                    if (string.IsNullOrEmpty(name))
                    {
                        continue;
                    }
                    var featureval = featurePair.Value;
                    rawFeatures.Set(name, BsonValue.Create(featureval));
                }
                featuresDocument.IntegrationId = integration.Id;
                featuresDocument.APIId         = integration.APIKey.Id;
                x.Features = null;
                return(rawFeatures);
            });
            var insertBatcher = new MongoInsertBatch <BsonDocument>(_featuresCollection, 3000);

            insertCreator.LinkTo(insertBatcher.BatchBlock, new DataflowLinkOptions {
                PropagateCompletion = true
            });
            //Insert our features
            _featuresBlock.LinkTo(insertCreator, new DataflowLinkOptions {
                PropagateCompletion = true
            });
            //After all data is processed, extract the features
            dataProcessingBlock.ContinueWith(() =>
            {
                var extractionTask = RunFeatureExtraction(donut);
                Task.WaitAll(extractionTask);
            });
            _harvester.SetDestination(dataProcessingBlock);

            var harvesterRun = await _harvester.Run();

            //If we have to repeat it, handle this..
            return(harvesterRun);
        }
Ejemplo n.º 6
0
        public ClassifyWindow(IFeatureGenerator fg)
        {
            InitializeComponent();

            this.fg    = fg;
            fg.Values += new ChangedFeaturesEventHandler(fg_Values);

            listModels.SelectedIndex     = -1;
            listModels.SelectionChanged += new SelectionChangedEventHandler(listModels_SelectionChanged);

            statusBar.Text = "Loading models. Please wait...";
            ms             = new ModelStorage();
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Creates a dataflow block encapsulating raw integrated document reading -> feature extraction.
        /// </summary>
        /// <returns></returns>
        public IDonutBlock <TData> CreateDataflowBlock(IFeatureGenerator <TData> featureGen)
        {
            var featuresBlock = featureGen.CreateFeaturesBlock();
            var metaBlock     = new MemberVisitingBlock <TData>(ProcessRecord);
            var decodeBlock   = new TransformFlowBlock <TData, TData>(new TransformBlock <TData, TData>(f =>
            {
                Context.DecodeFields(f);
                return(f);
            }));

            decodeBlock.LinkTo(metaBlock.GetInputBlock());
            return(new DonutBlock <TData>(decodeBlock, featuresBlock));
        }
        public MultiFeatureGenerator(IEnumerable <KeyValuePair <Combination, IFeatureGenerator> > featureGenerators, IFeatureGenerator defaultFeatureGenerator)
        {
            _defaultFeatureGenerator = defaultFeatureGenerator;
            _featureGenerators       = featureGenerators.ToArray();

            foreach (var featureGenerator in _featureGenerators)
            {
                if (featureGenerator.Value is UnitTestFeatureGenerator unitTestFeatureGenerator)
                {
                    unitTestFeatureGenerator.TestClassNameFormat += $"_{featureGenerator.Key.UnitTestProvider}_{featureGenerator.Key.TargetFramework}_{featureGenerator.Key.ProjectFormat}_{featureGenerator.Key.ProgrammingLanguage}";
                }
            }
        }
Ejemplo n.º 9
0
        void Clear()
        {
            if (!AsyncWorkerLoadModels.CancellationPending)
            {
                AsyncWorkerLoadModels.CancelAsync();
            }

            if (!AsyncWorkerProcess.CancellationPending)
            {
                AsyncWorkerProcess.CancelAsync();
            }

            this.fg = null;
            //AsyncWorkerProcess = null;
            //AsyncWorkerLoadModels = null;
        }
Ejemplo n.º 10
0
        public TrainForm(IFeatureGenerator fg)
        {
            InitializeComponent();

            this.fg    = fg;
            fg.Values += new ChangedFeaturesEventHandler(ovfg_Values);

            comboBoxSelectedClass.SelectedIndex      = 0;
            comboBoxRecordTime.SelectedIndex         = 0;
            comboBoxRecordTime.SelectedIndexChanged += new EventHandler(comboBoxRecordTime_SelectedIndexChanged);

            recordTimer          = new System.Timers.Timer();
            recordTimer.Interval = 1000;
            recordTimer.Elapsed += new System.Timers.ElapsedEventHandler(recordTimer_Elapsed);

            AsyncWorkerCalculate = new BackgroundWorker();
            AsyncWorkerCalculate.WorkerReportsProgress      = true;
            AsyncWorkerCalculate.WorkerSupportsCancellation = true;
            AsyncWorkerCalculate.ProgressChanged           += new ProgressChangedEventHandler(AsyncWorkerCalculate_ProgressChanged);
            AsyncWorkerCalculate.RunWorkerCompleted        += new RunWorkerCompletedEventHandler(AsyncWorkerCalculate_RunWorkerCompleted);
            AsyncWorkerCalculate.DoWork += new DoWorkEventHandler(AsyncWorkerCalculate_DoWork);

            AsyncWorkerRecord = new BackgroundWorker();
            AsyncWorkerRecord.WorkerReportsProgress      = true;
            AsyncWorkerRecord.WorkerSupportsCancellation = true;
            AsyncWorkerRecord.ProgressChanged           += new ProgressChangedEventHandler(AsyncWorkerRecord_ProgressChanged);
            AsyncWorkerRecord.RunWorkerCompleted        += new RunWorkerCompletedEventHandler(AsyncWorkerRecord_RunWorkerCompleted);
            AsyncWorkerRecord.DoWork += new DoWorkEventHandler(AsyncWorkerRecord_DoWork);

            AsyncWorkerSaveModel = new BackgroundWorker();
            AsyncWorkerSaveModel.WorkerReportsProgress      = true;
            AsyncWorkerSaveModel.WorkerSupportsCancellation = true;
            AsyncWorkerSaveModel.RunWorkerCompleted        += new RunWorkerCompletedEventHandler(AsyncWorkerSaveModel_RunWorkerCompleted);
            AsyncWorkerSaveModel.DoWork += new DoWorkEventHandler(AsyncWorkerSaveModel_DoWork);

            ms = new ModelStorage();
            cbMethods.SelectedIndex = 0;
            recordTime = Convert.ToInt32(comboBoxRecordTime.Text);

            if (fg is OpenVibeFeatureGenerator)
            {
                listBoxLogger.Items.Insert(0, "You are required to wait until you see: \"Initialization took xxxxx ms\" in OpenVibe.");
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Loads the feature generators from a string representation.
        /// </summary>
        /// <param name="classNames">The class names.</param>
        /// <returns>IFeatureGenerator[].</returns>
        /// <exception cref="System.ArgumentNullException">classNames</exception>
        /// <exception cref="System.NotSupportedException">Unable to resolve the type #CLASS# with the SharpNL type resolver.</exception>
        /// <seealso cref="TypeResolver"/>
        private static IFeatureGenerator[] LoadFeatureGenerators(string classNames)
        {
            if (string.IsNullOrEmpty(classNames))
            {
                throw new ArgumentNullException("classNames");
            }

            var classes = classNames.Split(',');
            var fgs     = new IFeatureGenerator[classes.Length];

            for (int i = 0; i < classes.Length; i++)
            {
                var type = Library.TypeResolver.ResolveType(classes[i]);
                if (type == null)
                {
                    throw new NotSupportedException(
                              string.Format("Unable to resolve the type {0} with the SharpNL type resolver.", classes[i]));
                }

                fgs[i] = Library.GetInstance <IFeatureGenerator>(type);
            }
            return(fgs);
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Initializes a new instance of the <see cref="DocumentCategorizerFactory"/> with the specified tokenizer and the feature generatos.
        /// </summary>
        /// <param name="tokenizer">The tokenizer.</param>
        /// <param name="featureGenerators">The feature generators.</param>
        /// <exception cref="System.ArgumentNullException">
        /// <paramref name="tokenizer"/>
        /// or
        /// <paramref name="featureGenerators"/>
        /// </exception>
        /// <exception cref="System.ArgumentException">The specified tokenizer is not registered in the type resolver.</exception>
        public DocumentCategorizerFactory(ITokenizer tokenizer, IFeatureGenerator[] featureGenerators) {
            if (tokenizer == null)
                throw new ArgumentNullException("tokenizer");

            if (featureGenerators == null)
                throw new ArgumentNullException("featureGenerators");

            if (!Library.TypeResolver.IsRegistered(tokenizer.GetType()))
                throw new ArgumentException("The specified tokenizer is not registered in the type resolver.");

            foreach (var featureGenerator in featureGenerators) {

                if (featureGenerator == null)
                    throw new ArgumentException("The feature generators must not have any null objects.");

                if (!Library.TypeResolver.IsRegistered(featureGenerator.GetType()))
                    throw new ArgumentException(string.Format("The feature generator type {0} is not registered in the type resolver.", featureGenerator.GetType().Name));                   
                
            }


            this.featureGenerators = featureGenerators;
            this.tokenizer = tokenizer;
        }
 protected void GenerateFeature(IFeatureGenerator generator, SpecFlowFeature feature)
 {
     generator.GenerateUnitTestFixture(feature, "dummy", "dummyNS");
 }
Ejemplo n.º 14
0
 protected void GenerateFeature(IFeatureGenerator generator, Feature feature)
 {
     generator.GenerateUnitTestFixture(feature, "dummy", "dummyNS");
 }
Ejemplo n.º 15
0
 public FeatureGeneratorProviderExtended(IFeatureGenerator unitTestFeatureGenerator)
 {
     _unitTestFeatureGenerator = unitTestFeatureGenerator;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="LiveTestFeatureGenerator" /> class.
 /// </summary>
 /// <param name="baseFeatureGenerator">The base feature generator.</param>
 public LiveTestFeatureGenerator(IFeatureGenerator baseFeatureGenerator)
 {
   this.baseFeatureGenerator = baseFeatureGenerator;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="LiveTestFeatureGeneratorProvider" /> class.
 /// </summary>
 /// <param name="baseFeatureGenerator">The feature generator.</param>
 public LiveTestFeatureGeneratorProvider(UnitTestFeatureGenerator baseFeatureGenerator)
 {
     this.baseFeatureGenerator = baseFeatureGenerator;
 }
 protected void GenerateFeature(IFeatureGenerator generator, SpecFlowDocument document)
 {
     generator.GenerateUnitTestFixture(document, "dummy", "dummyNS");
 }
Ejemplo n.º 19
0
 public async Task <IHarvesterResult> Run(IDonutfile donut, IFeatureGenerator <TData> featureGenerator)
 => await Run(donut as TDonut, featureGenerator);
Ejemplo n.º 20
0
 /// <summary>
 /// Initializes a new instance of the <see cref="LiveTestFeatureGenerator" /> class.
 /// </summary>
 /// <param name="baseFeatureGenerator">The base feature generator.</param>
 public LiveTestFeatureGenerator(IFeatureGenerator baseFeatureGenerator)
 {
     this.baseFeatureGenerator = baseFeatureGenerator;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="LiveTestFeatureGeneratorProvider" /> class.
 /// </summary>
 /// <param name="baseFeatureGenerator">The feature generator.</param>
 public LiveTestFeatureGeneratorProvider(UnitTestFeatureGenerator baseFeatureGenerator)
 {
   this.baseFeatureGenerator = baseFeatureGenerator;
 }
        /* メソッド ****************************************************************/
        /// <summary>
        /// コンストラクタ生成時に渡された情報に従って特徴ベクトル生成器を構成します
        /// </summary>
        /// <param name="reader">音源ファイルを開いた状態のWaveReaderオブジェクト<para>情報取得に利用します。</para></param>
        private void SetGenerator(WaveReader reader)
        {
            IFeatureGenerator generator = null;
            var startupDir = System.Windows.Forms.Application.StartupPath;
            var fname = startupDir + @"\" + "filter.txt";

            switch (this.id)
            {
                case UnitMember.KMCustomUnit1c1d:
                    MinimumCondition condition1 = new MinimumCondition(50);
                    generator = new FeatureGenerator<KMCustomUnit1c1d>(condition1, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname); // 特徴ベクトル生成器のインスタンスを作る
                    break;
                case UnitMember.KMCustomUnit2c1d:
                    MinimumCondition condition2 = new MinimumCondition(50);
                    generator = new FeatureGenerator<KMCustomUnit2c1d>(condition2, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname); // 特徴ベクトル生成器のインスタンスを作る
                    break;
                case UnitMember.KMCustomUnit2c1dver2:
                    MinimumCondition condition3 = new MinimumCondition(50);
                    generator = new FeatureGenerator<KMCustomUnit2c1dver2>(condition3, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname); // 特徴ベクトル生成器のインスタンスを作る
                    break;
                case UnitMember.KMCustomUnit3c1d:
                    MinimumCondition condition4 = new MinimumCondition(5);
                    generator = new FeatureGenerator<KMCustomUnit3c1d>(condition4, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname); // 特徴ベクトル生成器のインスタンスを作る
                    break;
            }
            this._generator = generator;

            return;
        }
Ejemplo n.º 23
0
        /// <summary>
        /// Loads the feature generators from a string representation.
        /// </summary>
        /// <param name="classNames">The class names.</param>
        /// <returns>IFeatureGenerator[].</returns>
        /// <exception cref="System.ArgumentNullException">classNames</exception>
        /// <exception cref="System.NotSupportedException">Unable to resolve the type #CLASS# with the SharpNL type resolver.</exception>
        /// <seealso cref="TypeResolver"/>
        private static IFeatureGenerator[] LoadFeatureGenerators(string classNames) {
            if (string.IsNullOrEmpty(classNames))
                throw new ArgumentNullException("classNames");

            var classes = classNames.Split(',');
            var fgs = new IFeatureGenerator[classes.Length];

            for (int i = 0; i < classes.Length; i++) {
                var type = Library.TypeResolver.ResolveType(classes[i]);
                if (type == null)
                    throw new NotSupportedException(
                        string.Format("Unable to resolve the type {0} with the SharpNL type resolver.", classes[i]));

                fgs[i] = Library.GetInstance<IFeatureGenerator>(type);
            }
            return fgs;
        }
 public FlavoredFeatureGenerator(IFeatureGenerator featureGenerator, FlavoringConfiguration configuration)
 {
     _featureGenerator = featureGenerator ?? throw new ArgumentNullException(nameof(featureGenerator));
     _configuration    = configuration ?? throw new ArgumentNullException(nameof(configuration));
 }
 protected void GenerateFeature(IFeatureGenerator generator, SpecFlowDocument document)
 {
     generator.GenerateUnitTestFixture(document, "dummy", "dummyNS");
 }
Ejemplo n.º 26
0
        private void buttonStart_Click(object sender, EventArgs e)
        {
            buttonStart.Enabled = false;
            SelectedScenario    = comboBoxScenarioType.SelectedIndex;

            try
            {
                #region 1 Configure start

                IDigitalSignalProcessor dsp = null;
                if (cbEmotivDSP.Checked && cbEmotivDspMethod.SelectedIndex == 0)
                {
                    dsp = new BasicSignalProcessor();
                }
                if (cbFieldTripDSP.Checked && cbFieldTripDspMethod.SelectedIndex == 0)
                {
                    dsp = new BasicSignalProcessor();
                }

                if (rbuttonEmotiv.Checked)
                {
                    if (rbuttonEmotivSignal.Checked)
                    {
                        dataReader = new EmotivRawDataReader();
                    }
                    else
                    {
                        dataReader = new EmotivFileSystemDataReader(textBoxEmotivFile.Text);
                    }

                    int scenario = comboBoxScenarioType.SelectedIndex;
                    if (scenario == 1 || scenario == 2)                              //train and classify
                    {
                        IEpoching epocher = new TimeEpochGenerator(dataReader, 300); //this value depends on your BCI scenario
                        featureGenerator = new EigenVectorFeatureGenerator(epocher);
                    }
                }
                else if (rbuttonOpenVibe.Checked)
                {
                    dataReader = new OpenVibeRawDataReader();
                    int scenario = comboBoxScenarioType.SelectedIndex;
                    //if (scenario==5 || scenario==6) //these two acquire signal from OpenVibe
                    //{
                    //   IEpoching epocher = new CountEpochGenerator(dataReader, samples_per_chunk);
                    //   featureGenerator = new EigenVectorFeatureGenerator(epocher);
                    //}
                    //else
                    featureGenerator = new OpenVibeFeatureGenerator();
                }
                else if (rbuttonFieldTrip.Checked)
                {
                    dataReader = new FieldTripRawDataReader(this.tboxFieldTripHost.Text, Convert.ToInt32(this.ndFieldTripPort.Value));
                    int scenario = comboBoxScenarioType.SelectedIndex;
                    if (scenario == 1 || scenario == 2)
                    {
                        IEpoching epocher = new TimeEpochGenerator(dataReader, 300);//this value depends on your BCI scenario
                        featureGenerator = new EigenVectorFeatureGenerator(epocher);
                    }
                }

                if (dsp != null)
                {
                    dataReader.SetDspProcessor(dsp);
                }
                #endregion

                #region 2 Instantiate and run

                if (rbuttonExperimentator.Checked)
                {
                    //window created without background thread
                    ew = new WPF.ExperimentsWindow(); ew.Show(); currentWindow = ew;

                    currentWindow.Closed += delegate(object wsender, EventArgs we)
                    {
                        buttonStart.Text    = "Start";
                        buttonStart.Enabled = true;
                        ew = null;
                    };
                }
                else
                if (rbuttonEmotiv.Checked || rbuttonOpenVibe.Checked || rbuttonFieldTrip.Checked)
                {
                    switch (comboBoxScenarioType.SelectedIndex)
                    {
                    case 0:        //chart signal
                        if (rbuttonWPFcharting.Checked)
                        {
                            ow = new WPF.OutputWindow(dataReader, -1, -1); ow.Show(); currentWindow = ow;
                        }
                        else if (rbuttonWindowsFormsCharting.Checked)
                        {
                            of = new OutputForm(dataReader); of.Show(); of.Start(); currentForm = of;
                        }
                        break;

                    case 1: tf = new TrainForm(featureGenerator); tf.Show(); currentForm = tf; break;

                    case 2: cf = new ClassifyForm(featureGenerator); cf.Show(); currentForm = cf; break;

                    case 3: ow = new WPF.OutputWindow(dataReader, 165, 830); ow.Show(); currentWindow = ow; break; //xDAWN

                    case 4: ow = new WPF.OutputWindow(dataReader, 250, 830); ow.Show(); currentWindow = ow; break; //CSP

                    case 5: tf = new TrainForm(featureGenerator); tf.Show(); currentForm = tf; break;              //train

                    case 6: cf = new ClassifyForm(featureGenerator); cf.Show(); currentForm = cf; break;           //classify
                    }

                    if (rbuttonOpenVibe.Checked)
                    {
                        openVibeWorker.RunWorkerAsync();
                    }

                    if (currentForm != null)
                    {
                        currentForm.FormClosed += new FormClosedEventHandler(currentForm_FormClosed);
                    }
                    if (currentWindow != null)
                    {
                        currentWindow.Closed += new EventHandler(currentWindow_Closed);
                    }
                }

                if (currentWindow != null)
                {
                    System.Windows.Forms.Integration.ElementHost.EnableModelessKeyboardInterop(currentWindow);
                }
                #endregion
            }
            catch (Exception ex)
            {
                logger.Error(ex);
                if (ex.Message.IndexOf("edk.dll") >= 0)
                {
                    MessageBox.Show(ex.Message + "\r\n You need edk.dll and edk_utils.dll from the Emotiv Reseach SDK placed in Adastra's installation folder.");
                }
                else
                {
                    MessageBox.Show(ex.Message);
                }

                buttonStart.Enabled = true;
            }
            // }
        }