danalyzer.cs

用C#写的USB数据采集程序

                            a3 += d.X * d.X;
                            a4 += d.X * d.X * d.X;
                            a5 += d.X * d.X * d.X * d.X;
                            b1 += d.Fx;
                            b2 += d.Fx * d.X;
                            b3 += d.Fx * d.X * d.X;
                        }
                        a6 = a2 - a1 * a4 / a3;
                        a7 = a3 - a2 * a4 / a3;
                        a8 = a3 - a1 * a5 / a3 - a6 * (a4 - a2 * a5 / a3) / a7;
                        b4 = b2 - b1 * a4 / a3;
                        b5 = b3 - b1 * a5 / a3 - b4 * (a4 - a2 * a5 / a3) / a7;
                        //计算结果
                        x1 = b5 / a8;
                        x2 = (b4 - a6 * x1) / a7;
                        x3 = (b1 - a1 * x1 - a2 * x2) / a3;
                        result.A = x1;
                        result.B = x2;
                        result.C = x3;
                    }
                    break;
                default:
                    break;
            }
            return result;
        }

        #endregion

		#region "求面积"
		/// <summary>
		/// 面积计算
		/// </summary>
		/// <param name="data"></param>
		/// <returns></returns>
		public double Area(int[] data)
		{
			//添加面积计算的代码
		}
		#endregion

        #endregion

        #region "受保护的方法"

        #region "能谱变换"
        /// <summary>
        /// 能谱变换
        /// </summary>
        /// <param name="data"></param>
        /// <param name="paras"></param>
        protected void Transform(ref int[] data, params int[] paras)
        {
            if (paras.Length % 2 == 0)
            {
                throw new Exception("Parameters is not odd.");
            }
            if (data.Length > paras.Length)
            {
                int k = (int)((paras.Length - 1) / 2);
                _data = new double[data.Length + k * 2];
                Array.Copy(data, 0, _data, k, data.Length);
                int i;
                int j;
                double sum = 0;
                int div = 0;
                //扩展边界数据
                for (j = 0; j < k; j++)
                {
                    _data[j] = data[k - j];
                    _data[_data.GetUpperBound(0) - j] = data[data.GetUpperBound(0) - (k - j)];
                }
                //根据参数计算
                for (i = 0; i < paras.Length; i++)
                {
                    div += paras[i];
                }

                for (i = k; i < _data.Length - k; i++)
                {
                    for (j = 0; j < k; j++)
                    {
                        sum += paras[j] * _data[i - (k - j)] + paras[paras.GetUpperBound(0) - j] * _data[i + (k - j)];
                    }
                    sum += paras[j] * _data[i];
                    data[i - k] = (int)(sum / div);
                    sum = 0;
                }
            }
        }

        /// <summary>
        /// 能谱变换
        /// </summary>
        /// <param name="data"></param>
        /// <param name="paras"></param>
        protected void Transform(ref double[] data, double div, params int[] paras)
        {
            if (paras.Length % 2 == 0)
            {
                throw new Exception("parameter is not odd.");
            }
            if (data.Length > paras.Length)
            {
                int k = (int)((paras.Length - 1) / 2);
                _data = new double[data.Length + k * 2];
                Array.Copy(data, 0, _data, k, data.Length);
                int i;
                int j;
                double sum = 0;
                //扩展边界数据
                for (j = 0; j < k; j++)
                {
                    _data[j] = data[k - j];
                    _data[_data.GetUpperBound(0) - j] = data[data.GetUpperBound(0) - (k - j)];
                }
                //根据参数计算
                for (i = k; i < _data.Length - k; i++)
                {
                    for (j = 0; j < k; j++)
                    {
                        sum += paras[j] * _data[i - (k - j)] + paras[paras.GetUpperBound(0) - j] * _data[i + (k - j)];
                    }
                    sum += paras[j] * _data[i];
                    data[i - k] = sum / div;
                    sum = 0;
                }
            }
        }

        #endregion

        #endregion

    }

    #region "平滑方法枚举"
    /// <summary>
    /// 平滑方法
    /// </summary>
	public enum SmoothType
    {
        /// <summary>
        /// 5点平滑
        /// </summary>
        points5,
        /// <summary>
        /// 7点平滑
        /// </summary>
        points7,
        /// <summary>
        /// 9点平滑
        /// </summary>
        points9,
        /// <summary>
        /// 11点平滑
        /// </summary>
        points11,
        /// <summary>
        /// 13点平滑
        /// </summary>
        points13,
    }
    #endregion

    #region "寻峰方法枚举"
    /// <summary>
    /// 寻峰方法
    /// </summary>
    public enum PeakType
    {
        /// <summary>
        /// 导数法
        /// </summary>
        derivative,
        /// <summary>
        /// 协方差法
        /// </summary>
        covariance,
        /// <summary>
        /// 匹配滤波器法
        /// </summary>
        filter,
        /// <summary>
        /// 线性拟合法
        /// </summary>
        linearity,
    }
    #endregion

    #region "最小二乘法拟合多项式次数枚举"
    /// <summary>
    /// 最小二乘法拟合多项式次数
    /// </summary>
    public enum MultinomialType
    {
        /// <summary>
        /// 1次
        /// </summary>
        Linear,
        /// <summary>
        /// 2次
        /// </summary>
        Square,
    }
    #endregion

    #region "寻峰结果结构"
    /// <summary>
    /// 寻峰结果
    /// </summary>
    public struct PeakResult
    {
        private double _channel;
        /// <summary>
        /// 道址
        /// </summary>
        public double Channel
        {
            get { return _channel; }
            set { _channel = value; }
        }

        private double _regionstartchannel;
        /// <summary>
        /// 左边界
        /// </summary>
        public double RegionStartChannel
        {
            get { return _regionstartchannel; }
            set { _regionstartchannel = value; }
        }
        private double _regionendchannel;
        /// <summary>
        /// 右边界
        /// </summary>
        public double RegionEndChannel
        {
            get { return _regionendchannel; }
            set { _regionendchannel = value; }
        }
    }
    #endregion

    #region "最小二乘法计算结果结构"
    /// <summary>
    /// 最小二乘法计算结果
    /// </summary>
    public struct  LeastSquareResult
    {
        private double _a;
        /// <summary>
        /// 零次项的系数
        /// </summary>
        public double A
        {
            get { return _a; }
            set { _a = value; }
        }

        private double _b;
        /// <summary>
        /// 一次项的系数
        /// </summary>
        public double B
        {
            get { return _b; }
            set { _b = value; }
        }
        private double _c;
        /// <summary>
        /// 二次项的系数
        /// </summary>
        public double C
        {
            get { return _c; }
            set { _c = value; }
        }
    }
    #endregion

    #region "最小二乘法计算数据结构"
    /// <summary>
    /// 最小二乘法计算数据
    /// </summary>
    public struct  LeastSquareData
    {
        private double _x;

        public double X
        {
            get { return _x; }
            set { _x = value; }
        }

        private double _fx;

        public double Fx
        {
            get { return _fx; }
            set { _fx = value; }
        }
    }
    #endregion
}