コード例 #1
0
ファイル: CyclicalNumerFilter.cs プロジェクト: yxw027/GNSSer
 /// <summary>
 /// 构造函数
 /// </summary>
 /// <param name="MaxError"></param>
 /// <param name="IsRelativeError"></param>
 public CyclicalNumerFilter(double MaxError, bool IsRelativeError)
 {
     this.MaxError = MaxError;
     AdjustFilter  = new AdjustFilter();
     FactionCutter = new PeriodPipeFilter(1, 0.5);
     Index         = -1;
     ErrorJudge    = new ErrorJudge(MaxError, IsRelativeError);
 }
コード例 #2
0
ファイル: CyclicalNumerFilter.cs プロジェクト: yxw027/GNSSer
        /// <summary>
        /// 当前值是否粗差。
        /// </summary>
        /// <returns></returns>
        private bool IsGrossError()
        {
            var alignedValue = CurrentRawValue.Value - IntegerPart;

            var isError = ErrorJudge.IsOverLimit(alignedValue, CurrentFilteredFraction.Value);

            return(isError);
        }
コード例 #3
0
ファイル: CyclicalNumerFilter.cs プロジェクト: yxw027/GNSSer
        /// <summary>
        /// 计算返回滤波后的数据,为小数部分的滤波值。
        /// </summary>
        /// <returns></returns>
        public CyclicalNumerFilter Calculate()
        {
            if (_isCurrentSolved)
            {
                return(this);
            }
            _isCurrentSolved = true;

            Index++;
            //决定截取整数部分
            if (IsNeedInitValue())
            {
                this.CurrentFilteredFraction = GetInitValue(CurrentRawValue);
            }
            else
            {
                var isError = IsGrossError();
                if (isError)                                                                //用于判断是周跳,还是粗差。
                {
                    var isGrossError = ErrorJudge.IsJumped(Buffers, CurrentRawValue.Value); //注意缓存为未对齐数据
                    if (isGrossError)                                                       //粗差,剔除,返回原来的。 //粗差不动,沿用当前
                    {
                        return(this);
                    }
                    else //发生周跳,重新初始化
                    {
                        var init = GetInitValue(CurrentRawValue);//
                        this.CurrentFilteredFraction = FilterAlignedValue(init);
                    }
                }
                else
                {
                    //滤波
                    this.CurrentFilteredFraction = FilterAlignedValue(new RmsedNumeral(CurrentRawValue.Value - IntegerPart, CurrentRawValue.Rms));
                }
            }
            this.CurrentFilteredValue = new RmsedNumeral(CurrentFilteredFraction.Value + IntegerPart, CurrentFilteredFraction.Rms);
            return(this);
        }
コード例 #4
0
        /// <summary>
        /// 新增加一个数据判断通过后才入库。
        /// 添加成功后返回true。
        /// </summary>
        /// <param name="key"></param>
        public override Boolean CheckAndAdd(double newVal, NumeralWindowData buffer)
        {
            //这里同父类一样,采用原始数据判断,以减少计算量。
            if (ErrorJudge.IsFirst)   // 第一次取其小数
            {
                IntBias = CaculateIntBias(buffer.GetNeatlyWindowData());
                ErrorJudge.SetReferenceValue(newVal);
            }
            else
            {
                ErrorJudge.SetReferenceValue(this.IntFraction.Value);
            }

            var fraction = newVal - IntBias;

            if (ErrorJudge.IsOverLimit(newVal))//判断是否超限
            {
                var list = buffer.InsertAndReturnNew(0, newVal);

                if (ErrorJudge.IsJumped(list))//跳跃,则重新计算整数值,否则认为是粗差,直接忽略。
                {
                    var newBuffer2 = new NumeralWindowData(list);
                    var biasBuffer = newBuffer2.GetNeatlyWindowData();
                    IntBias = CaculateIntBias(biasBuffer);

                    fraction = newVal - IntBias;
                    Add(fraction);
                    return(true);
                }
                return(false);
            }
            else
            {
                Add(fraction);
                return(true);
            }
        }
コード例 #5
0
 /// <summary>
 /// 构造函数。
 /// </summary>
 /// <param name="jugedWindowSize">窗口大小</param>
 public FloatNumberMaintainer(double MaxError, bool IsRelativeError = false)
 {
     ErrorJudge = new ErrorJudge(MaxError, IsRelativeError);
 }