Пример #1
0
        /// <summary>
        /// 生成所有可能的三角形,然后根据不同时段提取网络,计算闭合差
        /// </summary>
        /// <returns></returns>
        public AsyncTriguilarNetQualitiyManager BuildAsyncTriangularClosureQualies(GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy, int differPeriodCount)
        {
            //获取所有基线
            var lineNames = this.BaseLineManager.GetLineNamesWithEstValue();
            //由所有基线生成可能的三角网组合
            var triNetNames = TriangularNetName.BuildTriangularNetNames(lineNames, SiteManager.SiteNames);


            var differs = TimePeriod.GetDifferPeriods(this.BaseLineManager.Keys, differPeriodCount);

            //保存结果
            var CurrentQualityManager = new AsyncTriguilarNetQualitiyManager();

            foreach (var triNetName in triNetNames)
            {
                List <BaseLineNet> subNets = this.GetAsyncTriguilarNet(triNetName, differs);
                if (subNets == null || subNets.Count == 0)
                {
                    continue;
                }
                List <QualityOfTriAngleClosureError> list = new List <QualityOfTriAngleClosureError>();
                foreach (var subNet in subNets)
                {
                    var qulity = new QualityOfTriAngleClosureError(subNet, GnssReveiverNominalAccuracy);
                    list.Add(qulity);
                }
                CurrentQualityManager.Add(triNetName, list);
            }
            return(CurrentQualityManager);
        }
Пример #2
0
 /// <summary>
 /// 获取或创建复测基线较差
 /// </summary>
 /// <param name="GnssReveiverNominalAccuracy"></param>
 /// <param name="isRebuit"></param>
 /// <returns></returns>
 public RepeatErrorOfBaseLineManager GetOrCreateRepeatErrorOfBaseLineManager(GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy, bool isRebuit)
 {
     if (RepeatErrorOfBaseLineManager == null || isRebuit)
     {
         RepeatErrorOfBaseLineManager = CreateRepeatErrorOfBaseLineManager(GnssReveiverNominalAccuracy);
     }
     return(RepeatErrorOfBaseLineManager);
 }
Пример #3
0
 /// <summary>
 /// 构造函数
 /// </summary>
 /// <param name="LineName"></param>
 /// <param name="GnssReveiverNominalAccuracy"></param>
 public PeriodRepeatErrorOfBaseLine(
     SiteObsBaseline LineName,
     GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy
     )
 {
     this.GnssReveiverNominalAccuracy = GnssReveiverNominalAccuracy;
     this.BaseLine = LineName;
 }
Пример #4
0
 /// <summary>
 /// 闭合路径质量
 /// </summary>
 /// <param name="ClosureNet"></param>
 /// <param name="GnssReveiverNominalAccuracy"></param>
 public QualityOfTriAngleClosureError(BaseLineNet ClosureNet, GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy)
     : base(ClosureNet.First, ClosureNet.ClosureError, GnssReveiverNominalAccuracy)
 {
     this.BaseLineNet = ClosureNet;
     this.GnssReveiverNominalAccuracy = GnssReveiverNominalAccuracy;
     this.ClosureError = BaseLineNet.ClosureError;
     //计算闭合差
     if (BaseLineNet.ClosureError == null)
     {
         BaseLineNet.CalculateSetAndGetClosureError();
         Init(ClosureNet.First, ClosureNet.ClosureError, GnssReveiverNominalAccuracy);
     }
 }
Пример #5
0
        /// <summary>
        /// 获取复测基线较差
        /// </summary>
        /// <param name="GnssReveiverNominalAccuracy"></param>
        /// <returns></returns>
        public RepeatErrorOfBaseLineManager CreateRepeatErrorOfBaseLineManager(GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy)
        {
            RepeatErrorOfBaseLineManager result = new RepeatErrorOfBaseLineManager(GnssReveiverNominalAccuracy);

            var allObjLines = this.GetAllBaseLines();

            foreach (var item in allObjLines)
            {
                List <SiteObsBaseline> sameNameLines = GetLines(item.LineName);

                var repeatError = result.GetOrCreate(item);
                repeatError.Init(sameNameLines);
            }
            return(result);
        }
Пример #6
0
        /// <summary>
        /// 获取当前精度所处等级
        /// </summary>
        /// <param name="closureErrorMeter">闭合差,单位:米</param>
        /// <param name="distanceMeter">距离,单位:米</param>
        /// <returns></returns>
        public static GnssGradeType GetGnssGrade(double closureErrorMeter, double distanceMeter)
        {
            closureErrorMeter = Math.Abs(closureErrorMeter);

            var grades = Enum.GetNames(typeof(GnssGradeType));

            foreach (var grade in grades)//顺序从小到达
            {
                GnssGradeType gnssGrade = Geo.Utils.EnumUtil.Parse <GnssGradeType>(grade);
                var           tolerance = GnssReveiverNominalAccuracy.GetGnssGradeToleranceMeter(gnssGrade, distanceMeter);
                if (closureErrorMeter < tolerance)
                {
                    return(gnssGrade);
                }
            }
            return(GnssGradeType.No);
        }
Пример #7
0
        /// <summary>
        /// GNSS网的精度限差, 单位米
        /// </summary>
        /// <param name="gnssGrade">GNSS网等级</param>
        /// <param name="distanceMeter">基线长度,单位米</param>
        /// <returns>GNSS网的精度限差, 单位米</returns>
        public static double GetGnssGradeToleranceMeter(GnssGradeType gnssGrade, double distanceMeter)
        {
            double fixedError       = 3;
            double coefOfProportion = 1;

            switch (gnssGrade)
            {
            case GnssGradeType.AA:
                fixedError       = 3;
                coefOfProportion = 0.01;
                break;

            case GnssGradeType.A:
                fixedError       = 5;
                coefOfProportion = 0.1;
                break;

            case GnssGradeType.B:
                fixedError       = 8;
                coefOfProportion = 1;
                break;

            case GnssGradeType.C:
                fixedError       = 10;
                coefOfProportion = 5;
                break;

            case GnssGradeType.D:
                fixedError       = 10;
                coefOfProportion = 10;
                break;

            case GnssGradeType.E:
                fixedError       = 10;
                coefOfProportion = 20;
                break;

            default:
                break;
            }

            var mm = GnssReveiverNominalAccuracy.GetToleranceErrorMilliMeter(fixedError, coefOfProportion, distanceMeter);

            return(mm * 0.001); //单位转换为米
        }
Пример #8
0
        /// <summary>
        /// 重复基线较差质量检核结果
        /// </summary>
        /// <param name="periodsRepeatErrors"></param>
        /// <param name="GnssReveiverNominalAccuracy"></param>
        /// <returns></returns>
        public Dictionary <BufferedTimePeriod, RepeatErrorQualityManager> BuildRepeatBaselingQulities(MultiPeriodRepeatBaseLineError periodsRepeatErrors, GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy)
        {
            var         qualities = new Dictionary <BufferedTimePeriod, RepeatErrorQualityManager>();
            int         netIndex  = 1;
            BaseLineNet baseNet   = null;// phaselNets[0];

            foreach (var pkv in this.KeyValues)
            {
                var period   = pkv.Key;
                var totalNet = pkv.Value;


                if (baseNet == null)
                {
                    baseNet = totalNet; continue;
                }
                var netName = (netIndex + "-0");

                var asychCloserErrors = periodsRepeatErrors[period];

                var data = baseNet.BuildRepeatBaseLineError(totalNet, asychCloserErrors, GnssReveiverNominalAccuracy, netName);
                qualities[period] = data;
            }
            return(qualities);
        }
Пример #9
0
        /// <summary>
        /// 重复基线较差表格
        /// </summary>
        /// <param name="qualities"></param>
        /// <param name="GnssReveiverNominalAccuracy"></param>
        /// <param name="isBadOnly">是否只显示超限的</param>
        /// <returns></returns>
        public ObjectTableStorage BuildRepeatBaselingErrorTable(Dictionary <BufferedTimePeriod, RepeatErrorQualityManager> qualities, GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy, bool isBadOnly = false)
        {
            var asynchClosureError = new ObjectTableManager();
            int netIndex           = 1;

            foreach (var pkv in qualities)
            {
                var period   = pkv.Key;
                var totalNet = pkv.Value;
                var netName  = (netIndex + "-0");
                var data     = qualities[period];
                ObjectTableStorage lineTable = BaseLineNet.BuildRepeatBaseLineCheckResultTable(data, netName, isBadOnly);//用于显示,查看

                asynchClosureError.Add(lineTable);
                netIndex++;
            }
            var asyncErrorTable = asynchClosureError.Combine("复测基线较差");

            return(asyncErrorTable);
        }
Пример #10
0
        /// <summary>
        ///  GNSS 测量精度计算公式
        /// </summary>
        /// <param name="gnssReveiverType">接收机类型</param>
        /// <param name="distanceMeter">基线长度</param>
        /// <param name="version">版本</param>
        /// <returns></returns>
        public static LevelVertical GetReceiverToleranceError(GnssReveiverType gnssReveiverType, double distanceMeter, string version = null)
        {
            GnssReveiverNominalAccuracy accuracy = GetNominalAccuracyOfGnssReveiver(gnssReveiverType, version);

            return(accuracy.GetToleranceErrorMilliMeter(distanceMeter));
        }
Пример #11
0
 /// <summary>
 /// 构造函数
 /// </summary>
 /// <param name="baseLine"></param>
 /// <param name="ClosureError"></param>
 /// <param name="GnssReveiverNominalAccuracy"></param>
 public QualityBaseLine(EstimatedBaseline baseLine, RmsedXYZ ClosureError, GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy)
 {
     Init(baseLine, ClosureError, GnssReveiverNominalAccuracy);
 }
Пример #12
0
        /// <summary>
        /// 获取当前时段三角形闭合差
        /// </summary>
        /// <param name="timePeriodKey"></param>
        /// <param name="GnssReveiverNominalAccuracy"></param>
        /// <param name="isRebuit"></param>
        /// <returns></returns>
        public TriguilarNetQualitiyManager GetTriguilarNetQualitiyManager(TimePeriod timePeriodKey, GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy, bool isRebuit)
        {
            var dic = GetOrCreatePeriodSyncTriguilarNetQualitiyManager(GnssReveiverNominalAccuracy, isRebuit);

            var max = TimePeriod.GetMaxCommon(dic.Keys, timePeriodKey);

            if (max == null)
            {
                return(new TriguilarNetQualitiyManager());
            }

            return(dic[max]);
        }
Пример #13
0
 /// <summary>
 /// 获取各时段同步三角闭合差。
 /// </summary>
 /// <param name="GnssReveiverNominalAccuracy"></param>
 /// <param name="isRebuit"></param>
 /// <returns></returns>
 public PeriodTriguilarNetQualitiyManager GetOrCreatePeriodSyncTriguilarNetQualitiyManager(GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy, bool isRebuit)
 {
     if (PeriodTriguilarNetQualitiyManager == null || isRebuit)
     {
         PeriodTriguilarNetQualitiyManager = new PeriodTriguilarNetQualitiyManager();
         var nets = GetOrBuildPeriodBaseLineNet(isRebuit);
         foreach (var item in nets.KeyValues)
         {
             PeriodTriguilarNetQualitiyManager[item.Key] = item.Value.BuildTriangularClosureQualies(GnssReveiverNominalAccuracy);
         }
     }
     return(PeriodTriguilarNetQualitiyManager);
 }
Пример #14
0
 /// <summary>
 /// 构造函数
 /// </summary>
 /// <param name="GnssReveiverNominalAccuracy"></param>
 public RepeatErrorOfBaseLineManager(GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy)
 {
     this.GnssReveiverNominalAccuracy = GnssReveiverNominalAccuracy;
 }
Пример #15
0
 /// <summary>
 /// 初始化
 /// </summary>
 /// <param name="baseLine"></param>
 /// <param name="ClosureError"></param>
 /// <param name="GnssReveiverNominalAccuracy"></param>
 public void Init(EstimatedBaseline baseLine, RmsedXYZ ClosureError, GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy)
 {
     this.ClosureError                = ClosureError;
     this.EstimatedBaseline           = baseLine;
     this.GnssReveiverNominalAccuracy = GnssReveiverNominalAccuracy;
 }
Пример #16
0
        /// <summary>
        /// 提取各个基线质量检核情况
        /// </summary>
        /// <param name="GnssReveiverNominalAccuracy"></param>
        /// <returns></returns>
        public Dictionary <BufferedTimePeriod, TriguilarNetQualitiyManager> BuildTriangularClosureQualies(GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy)
        {
            var result = new Dictionary <BufferedTimePeriod, TriguilarNetQualitiyManager>();
            //同步环闭合差计算
            int    netIndex = 0;
            string name     = "Net";

            foreach (var pkv in this.KeyValues)
            {
                var period = pkv.Key;
                var net    = pkv.Value;

                var netName = name + (netIndex++).ToString("00");

                var qualities = net.BuildTriangularClosureQualies(GnssReveiverNominalAccuracy);

                result[period] = qualities;
            }
            return(result);
        }
Пример #17
0
 public bool IsOk(GnssBaseLineName lineName, GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy)
 {
     return(true);
 }
Пример #18
0
 /// <summary>
 /// 复测基线较差
 /// </summary>
 /// <param name="ClosureError"></param>
 /// <param name="baseLine"></param>
 /// <param name="GnssReveiverNominalAccuracy"></param>
 public QualityOfRepeatError(EstimatedBaseline baseLine, RmsedXYZ ClosureError, GnssReveiverNominalAccuracy GnssReveiverNominalAccuracy)
     : base(baseLine, ClosureError, GnssReveiverNominalAccuracy)
 {
     this.ClosureError                = ClosureError;
     this.EstimatedBaseline           = baseLine;
     this.GnssReveiverNominalAccuracy = GnssReveiverNominalAccuracy;
 }