Example #1
0
        protected void IDdiscont(object sender, EventArgs e)
        {
            if (combobox_avail.Active < 0)
            {
                return;
            }

            string port = combobox_avail.ActiveText;

            try
            {
                bool found = false;
                for (int i = 0; i < MainClass.devices.Length; i++)
                {
                    NIRSDAQ.info info = MainClass.devices[i].GetInfo();
                    if (port == info.PortName)
                    {
                        MainClass.devices[i].IDmode(true);
                        Thread.Sleep(3000);
                        MainClass.devices[i].IDmode(false);
                        found = true;
                    }
                }
                if (!found)
                {
                    XmlDocument doc = new XmlDocument();
                    doc.Load(@"BTNIRS_Config.xml");
                    NIRSDAQ.Instrument.Devices.TechEn.BTnirs bTnirs = new NIRSDAQ.Instrument.Devices.TechEn.BTnirs(doc);
                    bTnirs.Connect(port);
                    bTnirs.IDmode(true);
                    Thread.Sleep(3000);
                    bTnirs.IDmode(false);
                    bTnirs.Destroy();
                }
            }
            catch { }
        }
Example #2
0
        public ConnectDevices()
        {
            this.Build();

            if (MainClass.win.settings.SYSTEM.Trim().ToLower().Equals("simulator"))
            {
                checkbutton_simMode.Active = true;
                vbox_devices.Sensitive     = false;
                if (MainClass.devices == null)
                {
                    spinbutton_numSimDevices.Value = 1;
                }
                else
                {
                    spinbutton_numSimDevices.Value = MainClass.devices.Length;
                }
            }
            else if (MainClass.win.settings.SYSTEM.Trim().ToLower().Equals("simulatorhyperscan"))
            {
                checkbutton_simMode.Active     = true;
                vbox_devices.Sensitive         = false;
                spinbutton_numSimDevices.Value = 2;
            }
            else
            {
                checkbutton_simMode.Active     = false;
                vbox_devices.Sensitive         = true;
                spinbutton_numSimDevices.Value = 1;
            }

            XmlDocument doc = new XmlDocument();

            doc.Load(@"BTNIRS_Config.xml");
            NIRSDAQ.Instrument.Devices.TechEn.BTnirs bTnirs = new NIRSDAQ.Instrument.Devices.TechEn.BTnirs(doc);
            ports = bTnirs.ListPorts();

            connected = new List <string>();
            if (MainClass.devices != null)
            {
                for (int i = 0; i < MainClass.devices.Length; i++)
                {
                    NIRSDAQ.info info = MainClass.devices[i].GetInfo();

                    connected.Add(info.PortName);

                    if (ports.Contains(info.PortName))
                    {
                        ports.Remove(info.PortName);
                    }
                }
            }
            Gtk.ListStore ClearList = new Gtk.ListStore(typeof(string));
            combobox_connected.Model = ClearList;
            foreach (string s in connected)
            {
                combobox_connected.AppendText(s);
            }

            Gtk.ListStore ClearList2 = new Gtk.ListStore(typeof(string));
            combobox_avail.Model = ClearList2;
            foreach (string s in ports)
            {
                combobox_avail.AppendText(s);
            }
            combobox_avail.Active     = ports.Count - 1;
            combobox_connected.Active = connected.Count - 1;
        }
Example #3
0
        public RealtimeEngine()
        {
            nsamples = new int[MainClass.devices.Length];

            bool usehpf = MainClass.win._handles.useHPF.Active;
            bool uselpf = MainClass.win._handles.useLPF.Active;


            double hpf = 0.016;

            try
            {
                hpf = Convert.ToDouble(MainClass.win._handles.editHPF.Text);
            }
            catch
            {
                usehpf = false;
            }
            double lpf = 0.5;

            try
            {
                lpf = Convert.ToDouble(MainClass.win._handles.editLPF.Text);
            }
            catch
            {
                uselpf = false;
            }

            fs = new double[MainClass.devices.Length];
            OnlineFIRFiltersHPF  = new OnlineFilter[MainClass.devices.Length][];
            OnlineFIRFiltersHPF2 = new OnlineFilter[MainClass.devices.Length][];
            OnlineFIRFiltersLPF  = new OnlineFilter[MainClass.devices.Length][];
            MocoKalman           = new DiscreteKalmanFilter[MainClass.devices.Length][];

            mBLLmappings = new MBLLmapping[MainClass.devices.Length];

            for (int i = 0; i < MainClass.devices.Length; i++)
            {
                int nSDpairs = MainClass.win.nirsdata[i].probe.numChannels / MainClass.win.nirsdata[i].probe.numWavelengths;

                mBLLmappings[i]                  = new MBLLmapping();
                mBLLmappings[i].distances        = new double[nSDpairs];
                mBLLmappings[i].hboIndex         = new int[nSDpairs][];
                mBLLmappings[i].measurementPairs = new int[nSDpairs][];

                mBLLmappings[i].ExtCoefHbO = new double[nSDpairs][];
                mBLLmappings[i].ExtCoefHbR = new double[nSDpairs][];

                int   cnt  = 0;
                int[] cnt2 = new int[nSDpairs];
                for (int ii = 0; ii < nSDpairs; ii++)
                {
                    cnt2[ii] = 0;
                    mBLLmappings[i].hboIndex[ii]         = new int[2];
                    mBLLmappings[i].measurementPairs[ii] = new int[MainClass.win.nirsdata[i].probe.numWavelengths];
                    mBLLmappings[i].ExtCoefHbO[ii]       = new double[MainClass.win.nirsdata[i].probe.numWavelengths];
                    mBLLmappings[i].ExtCoefHbR[ii]       = new double[MainClass.win.nirsdata[i].probe.numWavelengths];
                }

                nirs.Media media = new nirs.Media();
                for (int sI = 0; sI < MainClass.win.nirsdata[i].probe.numSrc; sI++)
                {
                    for (int dI = 0; dI < MainClass.win.nirsdata[i].probe.numDet; dI++)
                    {
                        bool found = false;;
                        for (int mI = 0; mI < MainClass.win.nirsdata[i].probe.numChannels; mI++)
                        {
                            if (MainClass.win.nirsdata[i].probe.ChannelMap[mI].sourceindex == sI &
                                MainClass.win.nirsdata[i].probe.ChannelMap[mI].detectorindex == dI)
                            {
                                mBLLmappings[i].measurementPairs[cnt][cnt2[cnt]] = mI + MainClass.win.nirsdata[i].probe.numChannels;
                                if (mBLLmappings[i].hboIndex[cnt][0] == 0)
                                {
                                    mBLLmappings[i].hboIndex[cnt][0] = mI + MainClass.win.nirsdata[i].probe.numChannels * 2;
                                    mBLLmappings[i].hboIndex[cnt][1] = mI + nSDpairs + MainClass.win.nirsdata[i].probe.numChannels * 2;
                                }

                                mBLLmappings[i].distances[cnt] = 0;
                                media.GetSpectrum(MainClass.win.nirsdata[i].probe.ChannelMap[mI].wavelength,
                                                  out mBLLmappings[i].ExtCoefHbO[cnt][cnt2[cnt]], out mBLLmappings[i].ExtCoefHbR[cnt][cnt2[cnt]]);

                                mBLLmappings[i].distances[cnt] = Math.Sqrt((MainClass.win.nirsdata[i].probe.SrcPos[sI, 0] -
                                                                            MainClass.win.nirsdata[i].probe.DetPos[dI, 0]) *
                                                                           (MainClass.win.nirsdata[i].probe.SrcPos[sI, 0] -
                                                                            MainClass.win.nirsdata[i].probe.DetPos[dI, 0]) +
                                                                           (MainClass.win.nirsdata[i].probe.SrcPos[sI, 1] -
                                                                            MainClass.win.nirsdata[i].probe.DetPos[dI, 1]) *
                                                                           (MainClass.win.nirsdata[i].probe.SrcPos[sI, 1] -
                                                                            MainClass.win.nirsdata[i].probe.DetPos[dI, 1]));
                                cnt2[cnt]++;
                                found = true;
                            }
                        }
                        if (found)
                        {
                            cnt++;
                        }
                    }
                }



                nsamples[i] = 0;
                NIRSDAQ.info info = MainClass.devices[i].GetInfo();
                fs[i] = info.sample_rate;
                OnlineFIRFiltersHPF[i]  = new OnlineFilter[MainClass.win.nirsdata[i].probe.numChannels];
                OnlineFIRFiltersLPF[i]  = new OnlineFilter[MainClass.win.nirsdata[i].probe.numChannels];
                OnlineFIRFiltersHPF2[i] = new OnlineFilter[MainClass.win.nirsdata[i].probe.numChannels];
                MocoKalman[i]           = new DiscreteKalmanFilter[MainClass.win.nirsdata[i].probe.numChannels];

                for (int j = 0; j < MainClass.win.nirsdata[i].probe.numChannels; j++)
                {
                    OnlineFIRFiltersLPF[i][j]  = OnlineFilter.CreateLowpass(ImpulseResponse.Finite, fs[i], lpf);
                    OnlineFIRFiltersHPF[i][j]  = OnlineFilter.CreateHighpass(ImpulseResponse.Finite, fs[i], hpf);
                    OnlineFIRFiltersHPF2[i][j] = OnlineFilter.CreateHighpass(ImpulseResponse.Finite, fs[i], 0.001);

                    OnlineFIRFiltersHPF[i][j].Reset();
                    OnlineFIRFiltersHPF2[i][j].Reset();
                    OnlineFIRFiltersLPF[i][j].Reset();

                    int order = 5;
                    var x0    = MathNet.Numerics.LinearAlgebra.Matrix <double> .Build.Dense(order + 1, 1, 0);

                    var P0 = MathNet.Numerics.LinearAlgebra.Matrix <double> .Build.DenseIdentity(order + 1);

                    MocoKalman[i][j] = new DiscreteKalmanFilter(x0, P0);
                }
            }
        }