/// <summary>
/// 通用构造函数
/// </summary>
/// <param name="GlobalDataOption"></param>
/// <param name="option"></param>
/// <param name="session"></param>
public DataSourceContext(GnsserConfig GlobalDataOption, GnssProcessOption option, SessionInfo session)
: this()
{
this.GlobalDataOption = GlobalDataOption;
this.Option = option;
this.Session = session;
}
/// <summary>
/// 精密单点定位矩阵生成类 构造函数。
/// </summary>
/// <param name="option">解算选项</param>
public UncombinedPppMatrixBuilder(
GnssProcessOption option)
: base(option)
{
this.IsEstDcb = Option.IsEstDcbOfRceiver;
ParamNameBuilder = new UncombinedPppParamNameBuilder(option);//option中包含了几个系统
}
/// <summary>
/// 追加配置信息
/// </summary>
public string BuildOptionInfo(GnssProcessOption Option)
{
StringBuilder sb = new StringBuilder();
//配置选项
AppendLine(sb, "平差方法", Option.AdjustmentType);
AppendLine(sb, "定位类型", Option.PositionType);
AppendLine(sb, "近似数据", Option.ApproxDataType);
AppendLine(sb, "观测数据", Option.ObsDataType);
AppendLine(sb, "最大均方差限差", Option.MaxStdDev);
string str = "";
foreach (var item in Option.CycleSlipDetectSwitcher)
{
if (item.Value)
{
str += item.Key + ", ";
}
}
AppendLine(sb, "周跳探测方法", Option.CycleSlipDetectSwitcher.Count == 0 ? "默认" : str);
return(sb.ToString());
}
public virtual void EntityToUi()
{
if (Option == null)
{
Option = CreateNewModel();
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="option"></param>
/// <param name="BaseParamCount">基础参数数量</param>
public EpochDoublePhaseDifferMatrixBuilder(GnssProcessOption option, int BaseParamCount)
: base(option)
{
this.BaseParamCount = BaseParamCount;//
this.ParamNameBuilder = new EpochDoublePhaseDifferParamNameBuilder(this.Option, BaseParamCount);
IsDueFrequence = Option.ObsPhaseType == ObsPhaseType.L1AndL2;
}
/// <summary>
/// 数据分析
/// </summary>
public void Analysis()
{
if (RefObsDataSource == null || RovObsDataSource == null)
{
MessageBox.Show("请先读取数据。");
return;
}
FormUtil.ShowWaittingForm("正在对数据进行分析。。。");
GnssProcessOption option = GetModel(RovObsDataSource.ObsInfo.StartTime);
LoadDataSource();
DataSourceContext DataSourceContext = DataSourceContext.LoadDefault(option, this.textBox_obsPath_ref.Text, ephemerisDataSource, clockFile);
ObsDataAnalyst = new BaseLineObsDataAnalyst(DataSourceContext, RefObsDataSource, RovObsDataSource, option);
ObsDataAnalyst.SatCycleSlipMaker.SaveSatPeriodText(ProjectOutputDirectory + "\\SatCycleSlipMaker_" + DateTime.Now.Ticks + ".txt");
ObsDataAnalyst.SatVisibleMaker.SaveSatPeriodText(ProjectOutputDirectory + "\\SatVisibleMaker_" + DateTime.Now.Ticks + ".txt");
File.WriteAllText(ProjectOutputDirectory + "\\BaseSat_" + DateTime.Now.Ticks + ".txt", ObsDataAnalyst.SatelliteSelector.GetFormatedString());
var title = ("\r\n----------已经选择的基准卫星-----------\r\n");
ShowInfo(title + ObsDataAnalyst.SatelliteSelector.GetFormatedString());
title = ("\r\n----------卫星的可见性-----------\r\n");
ShowInfo(title + ObsDataAnalyst.SatVisibleMaker.ToFormatedString());
title = ("\r\n----------卫星周跳-----------\r\n");
ShowInfo(title + ObsDataAnalyst.SatCycleSlipMaker.ToFormatedString());
}
/// <summary>
/// 最简化的构造函数，可以多个定位器同时使用的参数，而不必多次读取
/// </summary>
/// <param name="DataSourceContext"></param>
/// <param name="PositionOption"></param>
public IonoFreePppOfTriFreq(DataSourceContext DataSourceContext, GnssProcessOption PositionOption)
: base(DataSourceContext, PositionOption)
{
this.Name = "三频无电离层组合PPP";
this.BaseParamCount = 5;
this.MatrixBuilder = new IonoFreePppOfTriFreqMatrixBuilder(PositionOption);
}
/// <summary>
/// 短基线载波相位差分。
/// </summary>
/// <param name="DataSourceContext">数据源</param>
/// <param name="Option">解算模型，数据输入模型</param>
public SingleDifferPositioner(DataSourceContext DataSourceContext, GnssProcessOption Option)
: base(DataSourceContext, Option)
{
this.Name = "载波相位单差";
this.BaseParamCount = 5;
this.MatrixBuilder = new SingleDifferMatrixBuilder(Option);
}
/// <summary>
/// 单频消电离层组合
/// </summary>
/// <param name="DataSourceContext"></param>
/// <param name="PositionOption"></param>
public SingleFreqIonoFreePppSolver(DataSourceContext DataSourceContext, GnssProcessOption PositionOption)
: base(DataSourceContext, PositionOption)
{
this.Name = "单频消电离层组合";
this.MatrixBuilder = new SingleFreqIonoFreePppMatrixBuilder(PositionOption);
PrevResults = new DicWindowData <int, SingleSiteGnssResult>(10);
}
/// <summary>
/// 最简化的构造函数，可以多个定位器同时使用的参数，而不必多次读取
/// </summary>
/// <param name="DataSourceContext"></param>
/// <param name="PositionOption"></param>
public RecursiveIonoFreePpp(DataSourceContext DataSourceContext, GnssProcessOption PositionOption)
: base(DataSourceContext, PositionOption)
{
this.Name = "无电离层组合PPP";
this.BaseParamCount = 5;
this.MatrixBuilder = new RecursiveIonoFreePppMatrixBuilder(PositionOption);
}
/// <summary>
/// 单站单历元GNSS计算预留测试类
/// </summary>
/// <param name="DataSourceContext"></param>
/// <param name="PositionOption"></param>
/// <param name="gnssMatrixBuilder"></param>
public CommonSingeSiteGnssSolver(DataSourceContext DataSourceContext, GnssProcessOption PositionOption, BaseGnssMatrixBuilder <SingleSiteGnssResult, EpochInformation> gnssMatrixBuilder)
: base(DataSourceContext, PositionOption)
{
this.Name = "通用单站单历元GNSS计算";
this.BaseParamCount = 5;
this.MatrixBuilder = gnssMatrixBuilder;
}
/// <summary>
/// 默认构造函数。
/// </summary>
public AmbiguityManager(GnssProcessOption Option)
{
this.AmbiguityFilePath = Option.AmbiguityFilePath;
this.IsUsingAmbiguityFile = Option.IsUsingAmbiguityFile;
this.SatObsDataType = Option.ObsDataType;
Init();
}
/// <summary>
/// 先构造，再设置历元值。
/// </summary>
/// <param name="option">解算选项</param>
public RecursiveIonoFreePppMatrixBuilder(
GnssProcessOption option)
: base(option)
{
this.ParamNameBuilder = new RecursiveIonoFreePppParamNameBuilder(option);
this.SecondParamNameBuilder = new RecursiveIonoFreePppSecondParamNameBuilder(option);
}
protected virtual void OnOptionChanged(GnssProcessOption Option)
{
if (OptionChanged != null)
{
OptionChanged(Option);
}
}
/// <summary>
/// 多站单历元GNSS计算预留测试类 构造函数。
/// </summary>
/// <param name="option">解算选项</param>
public MultiSiteGnssExtentMatrixBuilder(
GnssProcessOption option)
: base(option)
{
this.Option = option;
this.ParamNameBuilder = new MultiSiteGnssExtentParamNameBuilder(option);
}
/// <summary>
/// 最简化的构造函数，可以多个定位器同时使用的参数，而不必多次读取
/// </summary>
/// <param name="DataSourceContext"></param>
/// <param name="PositionOption"></param>
public IonoFreePpp(DataSourceContext DataSourceContext, GnssProcessOption PositionOption)
: base(DataSourceContext, PositionOption)
{
this.Name = "无电离层组合PPP";
this.BaseParamCount = 5;
if (PositionOption.ApproxDataType == SatApproxDataType.ApproxPseudoRangeOfTriFreq || PositionOption.ApproxDataType == SatApproxDataType.ApproxPhaseRangeOfTriFreq)
{
this.MatrixBuilder = new IonoFreePppOfTriFreqMatrixBuilder(PositionOption);
}
else
{
this.MatrixBuilder = new IonoFreePppMatrixBuilder(PositionOption);
}
if (!Option.TopSpeedModel)
{
if (this.IsFixingAmbiguity)
{
this.WideLaneBiasService = new WideLaneBiasService(Setting.GnsserConfig.IgnWideLaneFile);
this.IsBaseSatelliteRequried = true;
}
if (true)
{
if (!this.Option.IsUseFixedParamDirectly && (this.IsFixingAmbiguity && this.DataSourceContext.GnsserFcbOfUpdService == null))
{
throw new Exception("PPP模糊度固定，请设置FCB文件路径!");
}
}
else
{
FcbDataService = new FcbDataService("E:\\");
}
NarrawLaneFcbService = this.DataSourceContext.GnsserFcbOfUpdService;// new FcbOfUpdService( Option.GnsserFcbFilePath);
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="context"></param>
/// <param name="option"></param>
public BaseAbstractGnssSolver(DataSourceContext context, GnssProcessOption option)
{
this.DataSourceContext = context;
this.Option = option;
this.Name = context.ObservationDataSource == null ? "GNSS计算器" : context.ObservationDataSource.Name;
if (option.IsEphemerisRequired && (this.DataSourceContext.EphemerisService == null || this.DataSourceContext.EphemerisService.Prns.Count == 0))
{
var info = "不可计算！星历不可为空！";
log.Error(info);
throw new ArgumentException(info);
}
this.IsBaseSatelliteRequried = Option.IsBaseSatelliteRequried;
this.IsBaseSiteRequried = Option.IsBaseSiteRequried;
this.BaseSiteName = Option.IndicatedBaseSiteName;
this.IsFixingAmbiguity = Option.IsFixingAmbiguity;
this.IsPostCheckEnabled = Option.IsResultCheckEnabled;
this.MatrixAdjuster = AdjusterFactory.Create(this.Option.AdjustmentType);
if (MatrixAdjuster is RecursiveAdjuster)
{
((RecursiveAdjuster)MatrixAdjuster).SetStepOfRecursive(Option.StepOfRecursive);
}
this.ElementResidualCheckers = new PostResidualCheckerManager(this.Option.MaxErrorTimesOfPostResdual);
AdjustChecker = GnssResultCheckingManager.GetDefault(Option);
this.Init();
}
/// <summary>
/// 无电离层双差矩阵构造器
/// </summary>
/// <param name="option"></param>
/// <param name="baseParamCount"></param>
public RecursiveNetDoubleDifferPositionMatrixBuilder(
GnssProcessOption option, int baseParamCount)
: base(option, baseParamCount)
{
this.ParamNameBuilder = new RecursiveNetDoubleDifferPositionParamNameBuilder(option);
this.SecondParamNameBuilder = new RecursiveNetDoubleDifferPositionSecondParamNameBuilder(option);
}
protected override void OnWizardCompleted()
{
base.OnWizardCompleted();
this.Enabled = false;
var netFiles = GroupRinexFileWizardPage.Result;
//ProgressBarWizardPage.Init(this.SelectFilePageControl.FilePathes.Length);
//nFilePath = SelectFilePageControl.NFilePath;
var singlePpType = SelectPointPositionTypePage.GetCurrent <TwoSiteSolverType>();
GnssSolverType type = GnssSolverTypeHelper.GetGnssSolverType(singlePpType);
if (Option == null)
{
Option = GnssProcessOptionManager.Instance[type];
}
Option.AdjustmentType = SelectAdjustmentPage.GetCurrent <AdjustmentType>();
this.Option.IsUpdateStationInfo = SiteInfoSetingPage.IsUpdateSiteInfo;
this.Option.IsStationInfoRequired = SiteInfoSetingPage.IsUpdateSiteInfo;
this.Option.IsUpdateEstimatePostition = SiteInfoSetingPage.IsUpdateEpochSiteCoord;
this.Option.PositionType = SiteInfoSetingPage.PositionType;
//this.Option.isup
//ProgressBarWizardPage.Init(this.SelectFilePageControl.FilePathes.Length);
backgroundWorker1.RunWorkerAsync();
}
/// <summary>
/// 单频 默认周跳探测器
/// </summary>
/// <param name="Option">GNSS数据处理选项</param>
/// <param name="isRevered">是否逆序探测，如果是，探测时将不会使用已有周跳信息</param>
/// <returns></returns>
public static CycleSlipDetectReviser DefaultSingeFrequencyDetector(GnssProcessOption Option, bool isRevered = false)
{
var isUseRecoredCsInfo = !isRevered && Option.IsUsingRecordedCycleSlipInfo;
CycleSlipDetectReviser reviser = new CycleSlipDetectReviser();
if (Option.BufferSize < 200)
{
reviser.Add(new HighDifferSlipDetector(Option)
{
IsUsingRecordedCsInfo = isUseRecoredCsInfo
});
reviser.Add(new AverageDetector(Option)
{
IsUsingRecordedCsInfo = isUseRecoredCsInfo
});
// reviser.Add(new LsPolyFitDetector(Option) { IsUsingRecordedCsInfo = isUseRecoredCsInfo });
reviser.Add(new GreyPolyFitDetector(Option)
{
IsUsingRecordedCsInfo = isUseRecoredCsInfo
});
}
return(reviser);
}
public virtual void UiToEntity()
{
if (Option == null)
{
Option = CreateNewModel();
}
}
private void button_viewObs_Click(object sender, EventArgs e)
{
if (ObsFile == null)
{
MessageBox.Show("请先读取数据！"); return;
}
var window = this.namedIntControl_smoothWindow.GetValue();
SmoothedRangeBuilderManager = new CarrierSmoothedRangeBuilderManager(true, window, true, IonoDifferCorrectionType.DualFreqCarrier);
ObjectTableStorage table = new ObjectTableStorage();
var EpochInfoBuilder = new RinexEpochInfoBuilder(ObsFile.Header);
var _obsDataSource = new RinexFileObsDataSource(ObsPath);
var option = new GnssProcessOption();
var context = DataSourceContext.LoadDefault(option, _obsDataSource);
var bufferedStream = new BufferedStreamService <EpochInformation>(_obsDataSource, option.BufferSize);
SatTimeInfoManager SatTimeInfoManager = new Gnsser.SatTimeInfoManager(_obsDataSource.ObsInfo.Interval);
var Reviser = EpochInfoReviseManager.GetDefaultEpochInfoReviser(context, option, SatTimeInfoManager);
var checker = EpochCheckingManager.GetDefaultCheckers(context, option);
int i = -1;
foreach (var item in bufferedStream)
{
i++;
//原始数据检核
var epochInfo = item;
if (!checker.Check(item))
{
continue;
}
//数据矫正
bool result = Reviser.Revise(ref epochInfo);
if (!result)
{
continue;
}
table.NewRow();
table.AddItem("Epoch", epochInfo.ReceiverTime.ToShortTimeString());
//计算伪距平滑值
foreach (var sat in epochInfo)
{
//观测值，或组合值
var rangeVal = sat.FrequenceA.PseudoRange.CorrectedValue; // sat[type].CorrectedValue;
var phaseVal = sat.FrequenceA.PhaseRange.CorrectedValue; // sat[option.PhaseTypeToSmoothRange].CorrectedValue;
var manager = SmoothedRangeBuilderManager.GetOrCreate(sat.Prn);
var smoothRangeVal = manager.SetRawValue(sat.ReceiverTime, rangeVal, phaseVal, sat.IonoLenOfL1ByDifferL1L2).SetReset(sat.IsUnstable).Build();
table.AddItem(sat.Prn + "_Raw", rangeVal + "");
table.AddItem(sat.Prn + "_Smooth", smoothRangeVal + "");
}
i++;
}
table.EndRow();
this.BindDataSource(table);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="DataSourceContext"></param>
/// <param name="GnssOption"></param>
public NetSingleDifferPositionSolver(DataSourceContext DataSourceContext, GnssProcessOption GnssOption)
: base(DataSourceContext, GnssOption)
{
this.Name = "单差网解定位";
this.BaseParamCount = 5;
this.IsBaseSatelliteRequried = true;//强制启用基准星
var distanceOfBaseline = (DataSourceContext.ObservationDataSources.BaseDataSource.SiteInfo.ApproxXyz - DataSourceContext.ObservationDataSources.OtherDataSource.SiteInfo.ApproxXyz).Length;
if (distanceOfBaseline <= GnssOption.MaxDistanceOfShortBaseLine)
{
this.BaseParamCount = 3;
}
else if (GnssOption.MaxDistanceOfShortBaseLine < distanceOfBaseline && distanceOfBaseline < GnssOption.MinDistanceOfLongBaseLine)
{
this.BaseParamCount = 4;
}
else
{
this.BaseParamCount = 5;
}
this.MatrixBuilder = new NetSingleDifferPositionMatrixBuilder(Option, this.BaseParamCount);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="DataSourceContext"></param>
/// <param name="GnssOption"></param>
public IonFreeDoubleDifferPositioner(DataSourceContext DataSourceContext, GnssProcessOption GnssOption)
: base(DataSourceContext, GnssOption)
{
//双差模糊度固定
this.DoubleIonFreeAmReslution = new DoubleIonFreeAmbiguityReslution();
this.ResidualsAnalysis = new ResidualsAnalysis();
this.DualBandCycleSlipDetector = new DualBandCycleSlipDetector();
this.Name = "无电离层组合双差";
this.BaseParamCount = 5;
this.IsBaseSatelliteRequried = true;//强制启用基准星
var distanceOfBaseline = (DataSourceContext.ObservationDataSources.BaseDataSource.SiteInfo.ApproxXyz - DataSourceContext.ObservationDataSources.OtherDataSource.SiteInfo.ApproxXyz).Length;
if (distanceOfBaseline <= GnssOption.MaxDistanceOfShortBaseLine)
{
this.BaseParamCount = 3;
}
else if (GnssOption.MaxDistanceOfShortBaseLine < distanceOfBaseline && distanceOfBaseline < GnssOption.MinDistanceOfLongBaseLine)
{
this.BaseParamCount = 4;
}
else
{
this.BaseParamCount = 5;
}
this.Option.IsBaseSatelliteRequried = true;//强制启用基准星
this.MatrixBuilder = new IonFreeDoubleDifferMatrixBuilder(Option, this.BaseParamCount);
//双差模糊度固定
this.DoubleIonFreeAmReslution = new DoubleIonFreeAmbiguityReslution(this.BaseParamCount);
this.ResidualsAnalysis = new ResidualsAnalysis();
}
/// <summary>
/// 先构造，再设置历元值。
/// </summary>
/// <param name="option">解算选项</param>
public SiteFixedIonoFreePppMatrixBuilder(
GnssProcessOption option)
: base(option)
{
option.IsFixingCoord = true;
ParamNameBuilder = new SiteFixedIonoFreePppParamNameBuilder(option);
}
protected override void OptionToUi(GnssProcessOption Option)
{
base.OptionToUi(Option);
checkBox_IsOpenReportWhenCompleted.Checked = Option.IsOpenReportWhenCompleted;
this.enumRadioControl1_GnssSolverType.SetCurrent <GnssSolverType>(Option.GnssSolverType);
this.enumRadioControl_positionType.SetCurrent <PositionType>(Option.PositionType);
}
/// <summary>
/// 单站多历元GNSS计算预留测试类
/// </summary>
/// <param name="DataSourceContext"></param>
/// <param name="GnssOption"></param>
public SingleSitePeriodGnssExtentSolver(DataSourceContext DataSourceContext, GnssProcessOption GnssOption)
: base(DataSourceContext, GnssOption)
{
//InitDetect();
this.Name = "单站多历元GNSS计算预留测试类";
this.MatrixBuilder = new SingleSitePeriodGnssExtentMatrixBuilder(GnssOption);
}
/// <summary>
/// 时段计算
/// </summary>
/// <param name="files"></param>
/// <param name="Option"></param>
/// <param name="netPeriod"></param>
private void RunPpp(List <ObsSiteInfo> files, GnssProcessOption Option, TimePeriod netPeriod)
{
if (files.Count == 0)
{
log.Warn("没有文件！"); return;
}
//设置独立的输出目录
var OriginalDirectory = Option.OutputDirectory;
Option.OutputDirectory = Option.GetSolverDirectory(netPeriod);
Geo.Utils.FileUtil.CheckOrCreateDirectory(Option.OutputDirectory);
this.ObsSiteInfos = new ObsSiteInfos(files);
var pppRunner = new PointPositionBackGroundRunner(Option, ObsSiteInfos.GetFilePathes().ToArray());
pppRunner.ParallelConfig = ParallelConfig;
pppRunner.ProgressViewer = ProgressViewer;
pppRunner.Processed += PppRunner_Processed;
pppRunner.Completed += PppRunner_Completed;
pppRunner.Init();
pppRunner.Run();
//恢复目录
Option.OutputDirectory = OriginalDirectory;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="Context"></param>
/// <param name="Option"></param>
public EpochDoublePhaseDifferPositioner(DataSourceContext Context, GnssProcessOption Option)
: base(Context, Option)
{
this.Name = "单历元载波相位双差";
//默认双差基础参数为3个坐标坐标
var distanceOfBaseline = (Context.ObservationDataSources.BaseDataSource.SiteInfo.ApproxXyz - Context.ObservationDataSources.OtherDataSource.SiteInfo.ApproxXyz).Length;
if (distanceOfBaseline <= Option.MaxDistanceOfShortBaseLine)
{
this.BaseParamCount = 3;
}
else if (distanceOfBaseline > Option.MaxDistanceOfShortBaseLine && distanceOfBaseline < Option.MinDistanceOfLongBaseLine)
{
this.BaseParamCount = 4;
}
if (distanceOfBaseline > Option.MaxDistanceOfShortBaseLine)
{
this.BaseParamCount = 4;
log.Warn("基线距离有点长： " + distanceOfBaseline.ToString("0.0000") + "m, 我们默认为 " + Option.MaxDistanceOfShortBaseLine + "m 内， 电离层可能影响精度，请使用无电离层计算。");
}
if (this.Option.IsEstimateTropWetZpd)
{
this.BaseParamCount = 4;
log.Warn("指定了对流层湿延迟估计");
}
this.IsBaseSatelliteRequried = true;//强制启用基准星
this.MatrixBuilder = new EpochDoublePhaseDifferMatrixBuilder(base.Option, BaseParamCount);
}
/// <summary>
/// 精密单点定位矩阵生成类 构造函数。
/// </summary>
/// <param name="option">解算选项</param>
public IonoModeledSingleFreqPppMatrixBuilder(
GnssProcessOption option)
: base(option)
{
this.BasicParamCount = 4;
ParamNameBuilder = new IonoModeledSingleFreqPppParamNameBuilder(option);//option中包含了几个系统
}
