コード例 #1
0
ファイル: RealTimeFilterView.cs プロジェクト: SamCZ/Arduino
        // Simple-Flattening
        private void ProcessData(ref double[] Data)
        {
            // baseline correction and scaling (-150 ..0.. +150 )
            //baselinefixandscale(ref Data);

            // pre-filter noise
            for (int level = 0; level < butterworth_level; level++)
            {
                ButterWorth.Process(ref Data,
                                    butterworth_use_lp, butterworth_freqlp, butterworth_powerlp,
                                    butterworth_use_hp, butterworth_freqhp, butterworth_powerhp); // 250, 70);
            }
            // baseline correction and scaling (-150 ..0.. +150 )
            Baseline.baselinefixandscale(ref Data);

            // db6-filtering
            for (int level = 0; level < db6_level; level++)
            {
                DB6.process(ref Data, true);
            }

            // haar-filtering
            for (int level = 0; level < haar_level; level++)
            {
                Haar.process(ref Data);
            }
        }
コード例 #2
0
ファイル: Diagnostics.cs プロジェクト: zambilo76/Arduino
        public void CalcDiag(double[] Data, Color[] DataColor)
        {
            int centerd = Data.Length / 2;
            // Find a Beat
            int        beatcnt = 0;
            List <int> beatp   = new List <int>();
            bool       a       = true;

            for (int i = 0; i < Data.Length; i++)
            {
                if (((DataColor[i] == Color.Red) || (DataColor[i] == Color.Lime)) && a)
                {
                    beatp.Add(i);
                    beatcnt++;
                    a = false;
                }

                if ((DataColor[i] != Color.Red) && (DataColor[i] != Color.Lime))
                {
                    a = true;
                }
            }

            // Found 3 beats ...
            if (beatp.Count > 2)
            {
                int      len1     = beatp[1] - beatp[0];
                int      len2     = beatp[2] - beatp[1];
                int      len      = (len1 + len2) / 2;
                int      lenh     = len / 2;
                double[] beatarea = new double[len];
                Color[]  bcol     = new Color[len];

                // clear
                for (int i = 0; i < len; i++)
                {
                    beatarea[i] = 0;
                    bcol[i]     = Color.White;
                }

                // copy
                double[] Data2 = new double[Data.Length];
                Data.CopyTo(Data2, 0);

//                Haar.process(ref Data2);

                for (int i = 0; i < len; i++)
                {
                    int bp = beatp[1] - (lenh / 2) + i;
                    if ((bp > -1) && (bp < Data2.Length))
                    {
                        beatarea[i] = Data2[bp];
                    }
                }

                // fix and scale (cause of haar)
                // store scale-factor to recalculate Scale/MV
                double usedscale = Baseline.baselinefixandscaleex(ref beatarea, 0, beatarea.Length, true);

                MaxFinder mf = new MaxFinder();

                mf.GetPeaks(beatarea, beatarea.Length / 5, false);
                int[] aPeaks = new int[mf._peaks.Count];
                mf._peaks.CopyTo(aPeaks);

                mf.GetPeaks(beatarea, beatarea.Length / 3, true);
                int[] aMinPeaks = new int[mf._peaks.Count];
                mf._peaks.CopyTo(aMinPeaks);


                // grrgrg  g->r->r->g->r->g
                //              /\     .
                //         _/\_/  \  _/ \_
                //                 \/
                //            p  q  s  t

                string searchword = "grrgrg";
                int[]  complex    = new int[6] {
                    -1, -1, -1, -1, -1, -1
                };
                // enough data?
                if ((aPeaks.Length >= 3) && (aMinPeaks.Length >= 3))
                {
                    // data in correct order ?!

                    string s    = "";
                    int[]  spos = new int[aPeaks.Length + aMinPeaks.Length];
                    int    j    = 0;
                    // construct data-string
                    for (int i = 0; i < beatarea.Length; i++)
                    {
                        if (aPeaks.Contains(i))
                        {
                            s      += "r";
                            spos[j] = i;
                            j++;
                        }
                        if (aMinPeaks.Contains(i))
                        {
                            s      += "g";
                            spos[j] = i;
                        }
                    }
                    // search for searchword data-string
                    if (s.Contains(searchword))
                    {
                        // okay we are having a grrgrg-komplex ... :-)
                        int sw = s.IndexOf(searchword);
                        if (sw > -1)
                        {
                            complex[0] = spos[sw + 0];
                            complex[1] = spos[sw + 1];
                            complex[2] = spos[sw + 2];
                            complex[3] = spos[sw + 3];
                            complex[4] = spos[sw + 4];
                            complex[5] = spos[sw + 5];
                        }
                    }
                }

                // Draw Colored ECG
                Graphics g      = Graphics.FromImage(fFrame);
                int      scalex = 3;
                g.FillRectangle(Brushes.Black, new Rectangle(0, 0, fFrame.Width, fFrame.Height));
                int cx = (fFrame.Width / 2) - ((beatarea.Length * scalex) / 2);
                g.DrawLine(Pens.White, cx, 125, cx + beatarea.Length * scalex, 125);
                for (int i = 0; i < beatarea.Length - 1; i++)
                {
                    int y1 = (int)(beatarea[i]);
                    int y2 = (int)(beatarea[i + 1]);
                    Pen pn = new Pen(bcol[i]);
                    g.DrawLine(pn, cx + i * scalex, 125 + y1, cx + (i + 1) * scalex, 125 + y2);
                    pn.Dispose();
                }

                // Draw Maximas
                foreach (int Peak in aPeaks)
                {
                    int y1 = (int)(beatarea[Peak]);
                    g.DrawEllipse(Pens.Red, new Rectangle(cx + Peak * scalex - 3, 125 + y1 - 3, 6, 6));
                }

                // Draw Minimas
                foreach (int Peak in aMinPeaks)
                {
                    int y1 = (int)(beatarea[Peak]);
                    g.DrawEllipse(Pens.LimeGreen, new Rectangle(cx + Peak * scalex - 3, 125 + y1 - 3, 6, 6));
                }
                // render complex (-1)
                if (complex[0] != -1)
                {
                    for (int i = 0; i < 6; i++)
                    {
                        g.DrawLine(Pens.White, cx + complex[i] * scalex, 125 - 70,
                                   cx + complex[i] * scalex, 125 + 70);
                    }
                }

                g.Dispose();
            }
        }