public StationBaseDetailWindow(RoundStationInfo p_stationBase)
{
InitializeComponent();
_activityNameTBlock.Text = SystemLoginService.CurrentActivity.Name;
_activityAddressTBlock.Text = SystemLoginService.CurrentActivityPlace.Name;
_statInfoGrid.DataContext = p_stationBase;
}
private void Stationdatagrid_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
RoundStationInfo selectstation = this.stationdatagrid.SelectedItem as RoundStationInfo;
StationDetailDialog dialog = new StationDetailDialog(selectstation.STATGUID);
dialog.ShowDialog(this);
}
/// <summary>
/// 取台站干扰信息
/// </summary>
/// <param name="Interfstation"></param>
/// <returns></returns>
private InterfereObject CreateInterfObjectFromStation(RoundStationInfo Interfstation, ComparableFreq freq)
{
InterfereObject intobject = new InterfereObject();
intobject.Guid = Interfstation.STATGUID;
intobject.Name = Interfstation.STAT_NAME;
intobject.Type = InterfereObjectEnum.周围台站;
intobject.Freq = freq.Freq;
intobject.Band = freq.Band;
return(intobject);
}
private void DrawStationToMap(RoundStationInfo station)
{
string imgUrl = "/CO_IA.UI.StationPlan;component/Images/station.png";
string id = station.STATGUID;
ActivityMap.ShowMap.RemoveSymbolElement(id);
//重写
//ActivityMap.ShowMap.DrawPoint(station.STAT_LG, station.STAT_LA, imgUrl, id, new List<KeyValuePair<string, object>> {
// new KeyValuePair<string,object>(GraphicStyle.ImageSource.ToString(),imgUrl),
// new KeyValuePair<string,object>(GraphicStyle.zIndex.ToString(),"6"),
// new KeyValuePair<string, object>(GraphicStyle.ToolTipText.ToString(),station.STAT_NAME),
// new KeyValuePair<string, object>("data",station)
//});
}
//public delegate void DeleFunc();
//public void Func()
//{
// CO_IA.UI.Collection.RealTimeMonitor realTimeMonitor = new CO_IA.UI.Collection.RealTimeMonitor(_freqPlanActivitys, _roundStationInfos);
// realTimeMonitor.AfterMonitor += realTimeMonitor_AfterMonitor;
// grid_monitor.Children.Add(realTimeMonitor);
//}
//public void TestMethod(object data)
//{
// System.Windows.Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal,
// new DeleFunc(Func));
//}
/// <summary>
/// 监测扫描后，执行计算干扰方法
/// </summary>
/// <param name="matchSignals">发送中的匹配信号</param>
/// <param name="unMatchSignals">未发送的匹配信号</param>
/// <param name="unknowSignals">未匹配上的信号</param>
void realTimeMonitor_AfterMonitor(List <AnalysisResult> matchSignals, List <AnalysisResult> unMatchSignals, List <AnalysisResult> unknowSignals)
{
if (_isPause == false)
{
//_freqPlanActivitys
//_roundStationInfos
List <ActivityEquipmentInfo> equipList = new List <ActivityEquipmentInfo>();
List <RoundStationInfo> statList = new List <RoundStationInfo>();
//扫描每隔5秒返回一次
//匹配的
foreach (AnalysisResult analysisResult in matchSignals)
{
ActivityEquipmentInfo equip = GetEquipment(analysisResult.FreqGuid);
if (equip != null)
{
equipList.Add(equip);
}
RoundStationInfo stat = GetRoundStation(analysisResult.FreqGuid);
if (stat != null)
{
statList.Add(stat);
}
}
//未匹配的计算
foreach (AnalysisResult analysisResult in unMatchSignals)
{
ActivityEquipmentInfo equip = GetEquipment(analysisResult.FreqGuid);
if (equip != null)
{
equipList.Add(equip);
}
RoundStationInfo stat = GetRoundStation(analysisResult.FreqGuid);
if (stat != null)
{
statList.Add(stat);
}
}
//未知信号
//foreach (AnalysisResult analysisResult in unknowSignals)
//{
//}
CalculateRealize(statList, equipList, unknowSignals);
}
}
private List <RoundStationInfo> GetRoundStationInfo()
{
List <RoundStationInfo> statList = new List <RoundStationInfo>();
RoundStationInfo stat1 = new RoundStationInfo();
//stat1.FreqActivity = new FreqPlanActivity();
stat1.EmitInfos = new List <FreqEmitInfo>();
List <EmitInfo> list1 = DataOperator.GetEmitInfo("CB161486E97E49E69E38DA7E8D065CD0");
stat1.EmitInfos = GetFreqEmitInfoList(list1);
RoundStationInfo stat2 = new RoundStationInfo();
//stat2.FreqActivity = new FreqPlanActivity();
stat2.EmitInfos = new List <FreqEmitInfo>();
List <EmitInfo> list2 = DataOperator.GetEmitInfo("0aed5de4ebf8434e8bba78fede459c33");
stat2.EmitInfos = GetFreqEmitInfoList(list2);
statList.Add(stat1);
statList.Add(stat2);
return(statList);
}
/// <summary>
/// 台站信息转周围台站信息
/// </summary>
/// <param name="pStationInfos"></param>
/// <param name="pFreqPlans"></param>
/// <param name="pStatFreqDic"></param>
/// <returns></returns>
private List <RoundStationInfo> StationInfoConvert(List <StationInfo> pStationInfos, List <FreqPlanActivity> pFreqPlans, Dictionary <string, FreqPlanSegment> pStatFreqDic)
{
List <RoundStationInfo> roundStations = new List <RoundStationInfo>(pStationInfos.Count);
for (int i = 0; i < pStationInfos.Count; i++)
{
StationInfo stationInfo = new RoundStationInfo();
StructClone.ClassClone(pStationInfos[i], ref stationInfo);
((RoundStationInfo)stationInfo).ActivityId = CO_IA.Client.RiasPortal.ModuleContainer.Activity.Guid;
((RoundStationInfo)stationInfo).PlaceId = _activityPlaceId;
((RoundStationInfo)stationInfo).FreqActivityGuid = _activityPlaceId;
//获取台站发射信息
List <FreqEmitInfo> emitInfos = GetStationSystemEmitInfo(pStationInfos[i].STATGUID, pStationInfos[i].STAT_APP_TYPE);
if (emitInfos != null && emitInfos.Count > 0)
{
foreach (var emit in emitInfos)
{
emit.StationGuid = pStationInfos[i].STATGUID;
emit.PlaceGuid = _activityPlaceId;
emit.NeedClear = NeedClearEunm.NotNeedClear;
emit.ClearResult = ClearResultEnum.NotClear;
}
}
((RoundStationInfo)stationInfo).EmitInfos = emitInfos;
FreqPlanSegment freqSegment = null;
if (pStatFreqDic.TryGetValue(((RoundStationInfo)stationInfo).STATGUID, out freqSegment))
{
if (freqSegment is FreqPlanActivity)
{
((RoundStationInfo)stationInfo).FreqActivityGuid = (freqSegment as FreqPlanActivity).Guid;
}
((RoundStationInfo)stationInfo).FreqPart = freqSegment;
}
roundStations.Add((RoundStationInfo)stationInfo);
}
return(roundStations);
}
/// <summary>
/// 获取发射机互调
/// </summary>
/// <param name="transmResult"></param>
/// <returns></returns>
private List <IMInterfereResult> GetTransmitterImResult(IMCompareResult transmResult)
{
List <IMInterfereResult> imInterfresultlst = new List <IMInterfereResult>();
if (transmResult != null)
{
#region 获取干扰结果
IMItemBase imBase = null;
for (int i = 0; i < transmResult.Values.Length; i++)
{
imBase = transmResult.Values[i];
ActivityEquipmentInfo equ = new ActivityEquipmentInfo();
ComparableFreq imfreq = imBase.IMFreqs[0];//发射互调的干扰频率存在IMFreqs中
equ = _equipments.FirstOrDefault(r => r.GUID == imfreq.FreqID);
bool isnewInterfere = true; //新的干扰,不存在dicIMInterfereResult字典中
if (equ != null)
{
if (this.dicIMInterfereResult.TryGetValue(equ, out imInterfresultlst))
{
isnewInterfere = false;
}
else
{
isnewInterfere = true;
imInterfresultlst = new List <IMInterfereResult>();
}
IMInterfereResult iminterfinfo = new IMInterfereResult();
iminterfinfo.InterfType = InterfereTypeEnum.发射机互调干扰;
iminterfinfo.InterfOrder = GetIMInterfOrder(imBase.Order);
iminterfinfo.Formual = imBase.Formula;
iminterfinfo.InterfObject = new List <InterfereObject>();
#region 获取干扰台站
ComparableFreq disfreq = imBase.DisturbedFreqs[0];
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipmentInfo Interfequ1 = _equipments.FirstOrDefault(r => r.GUID == disfreq.FreqID);
InterfereObject interfobject1 = null;
if (Interfequ1 != null)
{
interfobject1 = CreateInterfObjectFromEqu(Interfequ1);
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
RoundStationInfo Interfstation = _aroundStation.FirstOrDefault(r => r.STATGUID == disfreq.FreqID);
if (Interfstation != null)
{
interfobject1 = CreateInterfObjectFromStation(Interfstation, disfreq);
}
else
{
//如设备列表和周围台站列表中都没有此干扰物，则认为干扰物为其他（这种情况应该不会出现？？）
interfobject1 = CreateInterfObjectFromOther(imBase.DisturbedFreqs[0]);
}
}
iminterfinfo.InterfObject.Add(interfobject1);
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipmentInfo Interfequ2 = _equipments.FirstOrDefault(r => r.GUID == imBase.IMFreqs[1].FreqID);
InterfereObject interfobject2 = null;
if (Interfequ2 != null)
{
interfobject2 = CreateInterfObjectFromEqu(Interfequ2);
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
RoundStationInfo Interfstation = _aroundStation.FirstOrDefault(r => r.STATGUID == imBase.IMFreqs[1].FreqID);
if (Interfstation != null)
{
interfobject2 = CreateInterfObjectFromStation(Interfstation, imBase.IMFreqs[1]);
}
else
{
//如设备列表和周围台站列表中都没有此干扰物，则认为干扰物为其他（这种情况应该不会出现？？）
interfobject2 = CreateInterfObjectFromOther(imBase.IMFreqs[1]);
}
}
iminterfinfo.InterfObject.Add(interfobject2);
#endregion
imInterfresultlst.Add(iminterfinfo);
if (isnewInterfere)
{
this.dicIMInterfereResult.Add(equ, imInterfresultlst);
}
}
}
#endregion
}
return(imInterfresultlst);
}
/// <summary>
/// 获取邻频干扰结果
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
private List <InterfereResult> GetADJFreqInterfResult(AdjFreqCompareResult[] result)
{
List <InterfereResult> adjinterfresultlst = new List <InterfereResult>();
//干扰结果
foreach (AdjFreqCompareResult item in result)
{
ActivityEquipmentInfo equ = new ActivityEquipmentInfo();
equ = _equipments.FirstOrDefault(r => r.GUID == item.Keys[0].FreqID); //获取干扰设备
bool isnewInterfere = true; //新的干扰,不存在dicInterfereResult字典中
if (this.dicInterfereResult.TryGetValue(equ, out adjinterfresultlst))
{
isnewInterfere = false;
}
else
{
isnewInterfere = true;
adjinterfresultlst = new List <InterfereResult>();
}
#region 邻频干扰
if (item.UpperAdjFreqs != null && item.UpperAdjFreqs.Length > 0)
{
InterfereResult uadinterfInfo = new InterfereResult();
uadinterfInfo.InterfType = InterfereTypeEnum.邻频干扰;
uadinterfInfo.InterfOrder = InterfereOrderEnum.邻频;
uadinterfInfo.InterfObject = new List <InterfereObject>();
foreach (ComparableFreq uadjfreq in item.UpperAdjFreqs)
{
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipmentInfo Interfequ = _equipments.FirstOrDefault(r => r.GUID == uadjfreq.FreqID);
InterfereObject interfobject = null;
if (Interfequ != null)
{
interfobject = CreateInterfObjectFromEqu(Interfequ);
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
RoundStationInfo Interfstation = _aroundStation.FirstOrDefault(r => r.STATGUID == uadjfreq.FreqID);
if (Interfstation != null)
{
interfobject = CreateInterfObjectFromStation(Interfstation, uadjfreq);
}
else
{
AnalysisResult interfsignal = _illegalSignal.FirstOrDefault(r => r.Id == uadjfreq.FreqID);
if (interfsignal != null)
{
interfobject = CreateInterfObjectFromSignal(interfsignal, uadjfreq);
}
else
{
//如设备列表和周围台站列表中都没有此干扰物，则认为干扰物为其他（这种情况应该不会出现？？）
interfobject = CreateInterfObjectFromOther(uadjfreq);
}
}
}
uadinterfInfo.InterfObject.Add(interfobject);
}
adjinterfresultlst.Add(uadinterfInfo);
}
#endregion
#region 邻频干扰
if (item.LowerAdjFreqs != null && item.LowerAdjFreqs.Length > 0)
{
InterfereResult ladjinterfInfo = new InterfereResult();
ladjinterfInfo.InterfType = InterfereTypeEnum.邻频干扰;
ladjinterfInfo.InterfOrder = InterfereOrderEnum.邻频;
ladjinterfInfo.InterfObject = new List <InterfereObject>();
foreach (ComparableFreq ladjfreq in item.LowerAdjFreqs)
{
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipmentInfo Interfequ = _equipments.FirstOrDefault(r => r.GUID == ladjfreq.FreqID);
InterfereObject interfobject = null;
if (Interfequ != null)
{
interfobject = CreateInterfObjectFromEqu(Interfequ);
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
RoundStationInfo Interfstation = _aroundStation.FirstOrDefault(r => r.STATGUID == ladjfreq.FreqID);
if (Interfstation != null)
{
interfobject = CreateInterfObjectFromStation(Interfstation, ladjfreq);
}
else
{
AnalysisResult interfsignal = _illegalSignal.FirstOrDefault(r => r.Id == ladjfreq.FreqID);
if (interfsignal != null)
{
interfobject = CreateInterfObjectFromSignal(interfsignal, ladjfreq);
}
else
{
//如设备列表和周围台站列表中都没有此干扰物，则认为干扰物为其他（这种情况应该不会出现？？）
interfobject = CreateInterfObjectFromOther(ladjfreq);
}
}
}
ladjinterfInfo.InterfObject.Add(interfobject);
}
adjinterfresultlst.Add(ladjinterfInfo);
}
#endregion
if (isnewInterfere)
{
this.dicInterfereResult.Add(equ, adjinterfresultlst);
}
}
return(adjinterfresultlst);
}
/// <summary>
/// 获取同频干扰结果
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
private List <InterfereResult> GetSameFreqInterfResult(SameFreqCompareResult[] result)
{
List <InterfereResult> interfresultlst = new List <InterfereResult>();;
foreach (SameFreqCompareResult item in result)
{
ActivityEquipmentInfo equ = new ActivityEquipmentInfo();
equ = _equipments.FirstOrDefault(r => r.GUID == item.Keys[0].FreqID);
bool isnewInterfere = true; //新的干扰,不存在dicInterfereResult字典中
if (this.dicInterfereResult.TryGetValue(equ, out interfresultlst))
{
isnewInterfere = false;
}
else
{
isnewInterfere = true;
interfresultlst = new List <InterfereResult>();
}
InterfereResult sameinterfInfo = new InterfereResult();
sameinterfInfo.InterfType = InterfereTypeEnum.频干扰;
sameinterfInfo.InterfOrder = InterfereOrderEnum.频;
sameinterfInfo.InterfObject = new List <InterfereObject>();
#region 遍历干扰列表，取干扰设备或者干扰物
foreach (ComparableFreq freq in item.Values)
{
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipmentInfo Interfequ = _equipments.FirstOrDefault(r => r.GUID == freq.FreqID);
InterfereObject interfobject = null;
if (Interfequ != null)
{
interfobject = CreateInterfObjectFromEqu(Interfequ);
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
RoundStationInfo Interfstation = _aroundStation.FirstOrDefault(r => r.STATGUID == freq.FreqID);
if (Interfstation != null)
{
interfobject = CreateInterfObjectFromStation(Interfstation, freq);
}
else
{
AnalysisResult interfsignal = _illegalSignal.FirstOrDefault(r => r.Id == freq.FreqID);
if (interfsignal != null)
{
interfobject = CreateInterfObjectFromSignal(interfsignal, freq);
}
else
{
//如设备列表和周围台站列表中都没有此干扰物，则认为干扰物为其他（这种情况应该不会出现？？）
interfobject = CreateInterfObjectFromOther(freq);
}
}
}
sameinterfInfo.InterfObject.Add(interfobject);
}
#endregion
interfresultlst.Add(sameinterfInfo);
//将新的干扰结果加到字典中
if (isnewInterfere)
{
this.dicInterfereResult.Add(equ, interfresultlst);
}
}
return(interfresultlst);
}
