/// <summary>
/// 创建周围台站
/// </summary>
/// <returns></returns>
private void CreateSurroundStation(List <StationInfo> stations)
{
foreach (StationInfo station in stations)
{
// 去掉重复
int count = ActivityStationItemsSource.Count(r => r.STATGUID == station.STATGUID);
if (count == 0)
{
string statguid = station.STATGUID;
string stattype = station.STAT_APP_TYPE;
List <StationEmitInfo> stationEmit = GetStationEmitInfo(statguid, stattype);
StationInfo stat = new SurroundStationInfo();
StationClone(station, stat);
SurroundStationInfo surstat = (SurroundStationInfo)stat;
surstat.EmitInfo = stationEmit;
SurroundStationInfo asurstat = new ActivitySurroundStation();
StationClone(surstat, asurstat);
ActivitySurroundStation activitystation = (ActivitySurroundStation)asurstat;
activitystation.ActivityId = this.CurrentActivityPlace.ActivityGuid;
activitystation.PlaceId = this.CurrentActivityPlace.Guid;
ActivityStationItemsSource.Add(activitystation);
}
}
}
/// <summary>
/// 取台站干扰信息
/// </summary>
/// <param name="Interfstation"></param>
/// <returns></returns>
private InterfereObject CreateInterfObjectFromStation(ActivitySurroundStation Interfstation, ComparableFreq freq)
{
InterfereObject intobject = new InterfereObject();
intobject.Guid = Interfstation.STATGUID;
intobject.Name = Interfstation.STAT_NAME;
intobject.Type = InterfereObjectEnum.周围台站;
intobject.Freq = freq.Freq;
intobject.SpareFreq = freq.SpareFreq;
intobject.Band = freq.Band * 1000;
return(intobject);
}
void LoadStatFreq(List <ComparableFreq> p_freqList, List <ComparableFreq> p_rcfreqList, string p_freqID)
{
ActivitySurroundStation stat = GetSurroundStation(p_freqID);
if (stat != null)
{
foreach (StationEmitInfo freqInfo in stat.EmitInfo)
{
p_freqList.Add(new ComparableFreq(freqInfo.FreqEC == null ? 0 : (double)freqInfo.FreqEC, 0, freqInfo.FreqBand, freqInfo.Guid));
p_rcfreqList.Add(new ComparableFreq(freqInfo.FreqRC == null ? 0 : (double)freqInfo.FreqRC, 0, freqInfo.FreqBand, freqInfo.Guid));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void dataGridSurroundStation_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
if (e.LeftButton == MouseButtonState.Pressed)
{
DataGridRow dgr = DataGridRow.GetRowContainingElement(e.OriginalSource as FrameworkElement);
if (dgr != null)
{
ActivitySurroundStation surroundStation = dgr.DataContext as ActivitySurroundStation;
if (surroundStation != null)
{
StationDetailDialog dialog = new StationDetailDialog(surroundStation.STATGUID);
dialog.ShowDialog(this);
}
}
}
}
/// <summary>
/// 处理结算结果
/// </summary>
/// <param name="matchSignals">匹配到的数据</param>
/// <param name="unMatchSignals">没匹配到的数据</param>
/// <param name="unknowSignals">未知信号</param>
/// <param name="isUsedData">是否使用全部数据进行计算，因为跨线程问题，所以使用参数传递</param>
void LoadCalculateResult(List <AnalysisResult> matchSignals, List <AnalysisResult> unMatchSignals, List <AnalysisResult> unknowSignals, bool isUsedAllData)
{
if (_isPause == false)
{
List <ComparableFreq> matchFreqList = new List <ComparableFreq>();
List <ComparableFreq> matchRCFreqList = new List <ComparableFreq>();
List <ComparableFreq> unMatchFreqList = new List <ComparableFreq>();
List <ComparableFreq> unMatchRCFreqList = new List <ComparableFreq>();
//扫描每隔5秒返回一次
//匹配的
foreach (AnalysisResult analysisResult in matchSignals)
{
LoadEquipFreq(matchFreqList, matchRCFreqList, analysisResult.FreqGuid);
ActivitySurroundStation stat = GetSurroundStation(analysisResult.FreqGuid);
if (stat != null)
{
LoadStatFreq(matchFreqList, matchRCFreqList, stat.STATGUID);
}
}
//未匹配的计算
foreach (AnalysisResult analysisResult in unMatchSignals)
{
LoadEquipFreq(unMatchFreqList, unMatchRCFreqList, analysisResult.FreqGuid);
ActivitySurroundStation stat = GetSurroundStation(analysisResult.FreqGuid);
if (stat != null)
{
LoadStatFreq(unMatchFreqList, unMatchRCFreqList, stat.STATGUID);
}
}
//未知信号
LoadUnKnowSignalFreqs(unknowSignals);
if (isUsedAllData == false)
{
CalculateRealize(matchFreqList, matchRCFreqList, _unKnowSignalFreqs);
}
else
{
CalculateRealize(_calculateAllFreqs, _calculateAllRCFreqs, _unKnowSignalFreqs);
}
}
}
/// <summary>
/// 在地图上选中台站
/// </summary>
/// <param name="obj"></param>
private void surroundStationListControl_StationSelectionChanged(ActivitySurroundStation obj)
{
mapcontrol.StationSelectionChanges(obj);
}
public void StationSelectionChanges(ActivitySurroundStation station)
{
activityMap.ShowMap.SelectStation(station);
}
private void surroundStationListControl_StationSelectionChanged(ActivitySurroundStation obj)
{
Obj.screenMap.SelectStation(obj);
}
/// <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];
ActivityEquipment equ = new ActivityEquipment();
ComparableFreq imfreq = imBase.IMFreqs[0];//发射互调的干扰频率存在IMFreqs中
equ = _equipments.FirstOrDefault(r => r.Key == 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];
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipment Interfequ1 = _equipments.FirstOrDefault(r => r.Key == disfreq.FreqID);
InterfereObject interfobject1 = null;
if (Interfequ1 != null)
{
interfobject1 = CreateInterfObjectFromEqu(Interfequ1);
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
ActivitySurroundStation 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);
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipment Interfequ2 = _equipments.FirstOrDefault(r => r.Key == imBase.IMFreqs[1].FreqID);
InterfereObject interfobject2 = null;
if (Interfequ2 != null)
{
interfobject2 = CreateInterfObjectFromEqu(Interfequ2);
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
ActivitySurroundStation 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="receiverResult"></param>
/// <returns></returns>
private List <IMInterfereResult> GetReceiverImResult(IMCompareResult receiverResult)
{
List <IMInterfereResult> imInterfresultlst = new List <IMInterfereResult>();
if (receiverResult != null)
{
#region 获取干扰结果
IMItemBase imBase = null;
for (int i = 0; i < receiverResult.Values.Length; i++)
{
imBase = receiverResult.Values[i];
ActivityEquipment equ = new ActivityEquipment();
ComparableFreq disfreq = imBase.DisturbedFreqs[0];
equ = _equipments.FirstOrDefault(r => r.Key == disfreq.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 获取干扰台站
for (int k = 0; k < imBase.IMFreqs.Length; k++)
{
ComparableFreq freq = imBase.IMFreqs[k];
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipment Interfequ = _equipments.FirstOrDefault(r => r.Key == freq.FreqID);
InterfereObject interfobject = null;
if (Interfequ != null)
{
interfobject = CreateInterfObjectFromEqu(Interfequ);
interfobject.Freq = freq.Freq; //干扰频率有可能是备用频率
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
ActivitySurroundStation Interfstation = _aroundStation.FirstOrDefault(r => r.STATGUID == freq.FreqID);
if (Interfstation != null)
{
interfobject = CreateInterfObjectFromStation(Interfstation, freq);
}
else
{
//如设备列表和周围台站列表中都没有此干扰物，则认为干扰物为其他（这种情况应该不会出现？？）
interfobject = CreateInterfObjectFromOther(freq);
}
}
iminterfinfo.InterfObject.Add(interfobject);
}
#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)
{
ActivityEquipment equ = new ActivityEquipment();
equ = _equipments.FirstOrDefault(r => r.Key == item.Keys[0].FreqID); //获取干扰设备
//InterfereResult adjresult = new InterfereResult();
bool isnewInterfere = true; //新的干扰,不存在dicInterfereResult字典中
if (this.dicInterfereResult.TryGetValue(equ, out adjinterfresultlst))
{
isnewInterfere = false;
//adjresult = adjinterfresultlst[0];
}
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)
{
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipment Interfequ = _equipments.FirstOrDefault(r => r.Key == uadjfreq.FreqID);
InterfereObject interfobject = null;
if (Interfequ != null)
{
interfobject = CreateInterfObjectFromEqu(Interfequ);
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
ActivitySurroundStation Interfstation = _aroundStation.FirstOrDefault(r => r.STATGUID == uadjfreq.FreqID);
if (Interfstation != null)
{
interfobject = CreateInterfObjectFromStation(Interfstation, uadjfreq);
}
else
{
//如设备列表和周围台站列表中都没有此干扰物，则认为干扰物为其他（这种情况应该不会出现？？）
interfobject = CreateInterfObjectFromOther(uadjfreq);
}
}
interfobject.InterfFreq = uadjfreq.InterfereResult;
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)
{
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipment Interfequ = _equipments.FirstOrDefault(r => r.Key == ladjfreq.FreqID);
InterfereObject interfobject = null;
if (Interfequ != null)
{
interfobject = CreateInterfObjectFromEqu(Interfequ);
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
ActivitySurroundStation Interfstation = _aroundStation.FirstOrDefault(r => r.STATGUID == ladjfreq.FreqID);
if (Interfstation != null)
{
interfobject = CreateInterfObjectFromStation(Interfstation, ladjfreq);
}
else
{
//如设备列表和周围台站列表中都没有此干扰物，则认为干扰物为其他（这种情况应该不会出现？？）
interfobject = CreateInterfObjectFromOther(ladjfreq);
}
}
interfobject.InterfFreq = ladjfreq.InterfereResult;
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)
{
ActivityEquipment equ = new ActivityEquipment();
equ = _equipments.FirstOrDefault(r => r.Key == item.Keys[0].FreqID);
InterfereResult sameinterfInfo = new InterfereResult();
bool isnewInterfere = true; //新的干扰,不存在dicInterfereResult字典中
if (this.dicInterfereResult.TryGetValue(equ, out interfresultlst))
{
isnewInterfere = false;
sameinterfInfo = interfresultlst[0];
}
else
{
isnewInterfere = true;
interfresultlst = new List <InterfereResult>();
sameinterfInfo = new InterfereResult();
sameinterfInfo.InterfType = InterfereTypeEnum.频干扰;
sameinterfInfo.InterfOrder = InterfereOrderEnum.频;
sameinterfInfo.InterfObject = new List <InterfereObject>();
}
#region 遍历干扰列表，取干扰设备或者干扰物
foreach (ComparableFreq freq in item.Values)
{
//先在设备列表中查找，如果有，则认为干扰物为设备
ActivityEquipment Interfequ = _equipments.FirstOrDefault(r => r.Key == freq.FreqID);
InterfereObject interfobject = null;
if (Interfequ != null)
{
interfobject = CreateInterfObjectFromEqu(Interfequ);
}
else
{
//如设备列表中没有，则在周围台站列表中查找，如果有，则认为干扰物为设备
ActivitySurroundStation Interfstation = _aroundStation.FirstOrDefault(r => r.STATGUID == freq.FreqID);
if (Interfstation != null)
{
interfobject = CreateInterfObjectFromStation(Interfstation, freq);
}
else
{
//如设备列表和周围台站列表中都没有此干扰物，则认为干扰物为其他（这种情况应该不会出现？？）
interfobject = CreateInterfObjectFromOther(freq);
}
}
interfobject.InterfFreq = freq.InterfereResult;
sameinterfInfo.InterfObject.Add(interfobject);
}
#endregion
//将新的干扰结果加到字典中
if (isnewInterfere)
{
interfresultlst.Add(sameinterfInfo);
this.dicInterfereResult.Add(equ, interfresultlst);
}
}
return(interfresultlst);
}
