tools.cs

心电信号处理库文件

            List<double> localMaximum = new List<double>();
            List<double> locationOfLocalMaximum = new List<double>();

            int counter = 0;
            double maximum = double.NegativeInfinity;
            double poloha = 0;

            //CZ: looking from treshold
            for(int i =0; i < data.Length; i++)
            {
                if (peak == 0 && data[i] > treshold)
                {
                    intervals.Add(i);
                    peak = 1;
                }

                else if (peak == 1 && (data[i] < treshold || i == data.Length-1))
                {
                    intervals.Add(i);
                    peak = 0;
                }
            }

            if (intervals.Count == 1)
                intervals[1] = intervals[0];
            
            counter = 0;

            //looking for local maximum
            for (int i = 0; i < intervals.Count; i+=2)
            {
                //"interval going"
                for (int j = intervals[counter]; j < intervals[counter+1]; j++)
                {
                    if (data[j] > maximum)
                    {
                        maximum = data[j];
                        poloha = j;
                    }
                }

                localMaximum.Add(maximum);
                locationOfLocalMaximum.Add(poloha);
                maximum = double.NegativeInfinity;
                
                counter += 2;
            }
            
            //copy data
            double[,] returnValue = new double[localMaximum.Count, 2];

            for (int i = 0; i < localMaximum.Count; i++)
            {
                returnValue[i, 0] = locationOfLocalMaximum[i];
                returnValue[i, 1] = localMaximum[i];
            }

            return returnValue;
        }

        /// <summary>
        /// Get double field and return field with int values.
        ///         out[n] = (int)input[n];
        /// </summary>
        /// <param name="data">input from: out[n] = (int)input[n]</param>
        /// <returns></returns>
        public static int[] doubleToInt(double[] data)
        {
            int[] returnValue = new int[data.Length];
            for (int i = 0; i < data.Length; i++)
                returnValue[i] = (int) data[i];

            return returnValue;
        }

        /// <summary>
        /// Create vector.
        /// TODO!
        /// </summary>
        /// <param name="vstup"></param>
        /// <returns></returns>
        public static double[] makeVector(double[] vstup)
        {
            double[] returnValue = new double[(int) Tools.maxValue(vstup)];

            for (int i = 0; i < returnValue.Length; i++)
                if (isIn(vstup, i))
                    returnValue[i] = 1;
                else
                    returnValue[i] = 0;

            return returnValue;
        }

        /// <summary>
        /// Return true if input field contains number else return false.
        /// </summary>
        /// <param name="data">input field</param>
        /// <param name="number">test value</param>
        /// <returns></returns>
        public static bool isIn(double[] data, double number)
        {
            bool ok = false;

            for (int i = 0; i < data.Length; i++)
            {
                if (data[i] == number)
                    ok = true;
            }

            return ok;

        }

        /// <summary>
        /// Return new double field filled with zeros. Return field's length will be:
        ///         input_field.Length+numZeros.
        /// </summary>
        /// <param name="data">input field</param>
        /// <param name="numZeros">number of zeros</param>
        /// <returns></returns>
        public static double[] fil(double[] data, int numZeros)
        {
            double[] returnValue = new double[data.Length + numZeros];
            for (int i = 0; i < data.Length; i++)
                returnValue[i] = data[i];

            for (int i = data.Length; i < returnValue.Length; i++)
                returnValue[i] = 0;

            return returnValue;
        }

        /// <summary>
        /// Autocorrelation, computational complexy n^2.
        /// </summary>
        /// <param name="data">intput data</param>
        /// <returns></returns>
        public static double[] ACF(double[] data)
        {
            double[] ACFdata = new double[data.Length];
            int N = data.Length;

            for (int m = 0; m < N; m++)
            {
                for (int k = 0; k < N - 1 - m; k++)
                {
                    ACFdata[m] += data[k] * data[k + m];
                }

                ACFdata[m] /= (N - m);
            }

            return ACFdata;
        }

        /// <summary>
        /// Double field: 
        ///         output[n] = abs(input[n])
        /// </summary>
        /// <param name="data">input double field</param>
        /// <returns></returns>
        public static double[] abs(double[] data)
        {
            double[] returnValue = new double[data.Length];
            for (int i = 0; i < data.Length; i++)
            {
                if (data[i] < 0)
                    returnValue[i] = -data[i];
                else
                    returnValue[i] = data[i];
            }

            return returnValue;
        }

        /// <summary>
        /// CZ: funkce je implementovana spatne
        /// EN: not ready yet
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static double[] xcorr(double[] data)
        {
            int N = data.Length;
            double[] returnValue = new double[data.Length];
            double[] x1 = new double[data.Length+N];
            double[] x2 = new double[data.Length+N];

            //x1
            for (int i = 0; i < data.Length; i++)
                x1[i] = data[i];
            for (int i = 0; i < N - 1; i++)
                x1[i + data.Length] = 0;
            //x2
            for (int i = 0; i < N - 1; i++)
                x2[i] = 0;
            for (int i = 0; i < data.Length; i++)
                x2[i + N - 1] = data[i];
            

            for (int k = -1; k < N - 1; k++)
            {
                for(int i = 0; i < N - k; i++)
                {
                    returnValue[k+1] += x1[i] * x2[N + k + i];
                }
            }

            double delitel = returnValue[0];
            for (int i = 0; i < returnValue.Length; i++)
                returnValue[i] = returnValue[i] / delitel;
         
            return returnValue;
        }

        /// <summary>
        /// Print double field into Console line.
        /// </summary>
        /// <param name="data"></param>
        public static void print2Line(double[] data)
        {
            for (int i = 0; i < data.Length-1; i++)
                Console.Write(data[i]+", ");

            Console.WriteLine(data[data.Length-1]);
        }
        
        /// <summary>
        /// Compute power from double: power = data[n]*data[n]; from 1..data.Length
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static double power(double[] data)
        {
            if(data.Length > 0)
            {
                double P =0;
                for (int i = 0; i < data.Length; i++)
                    P += (data[i]*data[i]);
                
                return P;
            }
            else
                return 0;
        }

        /// <summary>
        /// Very easy sort.  Do this better pleas! :-).
        /// </summary>
        /// <param name="data"></param>
        public static void insertSort(double[] data)
        {
            int position = 0;
            double nejvetsi = Double.NegativeInfinity;
            int indexNejvetsi = 0;
            double swapVar = 0;

            for (int i = 0; i < data.Length; i++)
            {
                //najdu nejvetsi
                for (int j = position; j < data.Length; j++)
                {
                    if (data[j] > nejvetsi)
                    {
                        nejvetsi = data[j];
                        indexNejvetsi = j;
                    }
                }

                swapVar = data[position];
                data[position] = data[indexNejvetsi];
                data[indexNejvetsi] = swapVar;
                nejvetsi = Double.NegativeInfinity;
                position++;
            }

        }

        /// <summary>
        /// Not ready yet. TODO.
        /// </summary>
        /// <param name="data"></param>
        /// <param name="fileName"></param>
        public static void printToFile(double[] data, String fileName)
        {
            string file = Path.Combine(Application.StartupPath, fileName);

            //CZ: vytvoreni instance StreamWriteru
            StreamWriter sw = null;
            try
            {
                sw = new StreamWriter(file, false, Encoding.GetEncoding("windows-1250"));
            }
            catch (Exception ex)
            {
                MessageBox.Show("Chyba pri otevirani souboru "+fileName+": "+
                    ex.Message, Application.ProductName, MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
                return;
            }

            //zapis do souboru
            String toWrite;
            for (int i = 0; i < data.Length; i++)
            {
                toWrite = data[i].ToString();
                //toWrite = Convert.Encoding.Unicode;
                sw.Write(data[i]+" ");
            }

            //uzavreni souboru
            sw.Close();
        }

        /// <summary>
        /// Not ready yet. TODO.
        /// </summary>
        /// <param name="data"></param>
        /// <param name="fileName"></param>
        public static void printToFile(int[] data, String fileName)
        {
            IFormatProvider fen = new CultureInfo("en-us"); ;
            string file = Path.Combine(Application.StartupPath, fileName);

            //new StreamWriteru
            StreamWriter sw = null;
            try
            {
                sw = new StreamWriter(file, false, Encoding.GetEncoding("windows-1250"));
            }
            catch (Exception ex)
            {
                MessageBox.Show("Chyba pri otevirani souboru " + fileName + ": " +
                    ex.Message, Application.ProductName, MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
                return;
            }

            //write to file
            String toWrite;
            for (int i = 0; i < data.Length; i++)
            {
                toWrite = data[i].ToString(fen);
                sw.WriteLine(data[i]);
            }

            //close file
            sw.Close();
        }

        /// <summary>
        /// Return location of maximum froum double field.
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static int positionOfMax(double[] data)
        {
            int pos = 0;
            double maximum = data[0];
            for (int i = 0; i < data.Length; i++)
            {
                if (maximum > data[i])
                {
                    maximum = data[i];
                    pos = i;
                }
            }

            return pos;
        }

        /// <summary>
        /// Compute square sum from double field: 
        ///         power = sum(data[n]*data[n]); from 1..data.Length
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static double squareSum(double[] data)
        {
            double sum = 0;

            for(int i = 0; i < data.Length; i++)
            {
                sum += data[i] * data[i];
            }

            return sum;
        }
    }
}