public EMIDataForm(EMIFileData data)
{
InitializeComponent();
SiteIDEditor.Text = data.Site_ID;
SiteNameEditor.Text = data.Site_ID;
AddressEditor.Text = data.Site_Address;
EngineerEditor.Text = data.PA_UserName;
DateEditor.Text = data.PA_TestTime;
LongtitudeEditor.Text = Utility.ConvertLongtitude(data.Site_Longitude);
LatitudeEditor.Text = Utility.ConvertLatitude(data.Site_Latitude);
}
public void AddEmiFile(string emiFile, EMIFileData emiData)
{
if (EMIFileCheckedListBox.Items.IndexOf(emiFile) >= 0)
return;
mEMIDatas.Add(emiFile, emiData);
EMIFileCheckedListBox.Items.Add(emiFile);
EMIFileCheckedListBox.SetItemChecked(EMIFileCheckedListBox.Items.Count - 1, true);
DataCenter.Instance().UploadFiles.Add(emiFile);
DataCenter.Instance().StoreData();
}
public ReportViewForm(Report report)
{
InitializeComponent();
SingleAnalysisTabPage.Text = "360\x00B0Analysis";
mIsViewReport = true;
mViewReport = report;
mTask = DataCenter.Instance().Tasks[report.TaskID];
mChannelSettings = DataCenter.Instance().ChannelSettings[report.ChannelSettingID];
mEmiFileData = DataCenter.Instance().EMIs[mViewReport.EmiFileID];
mLimitSetting = mViewReport.LimitSetting;
}
public VenezuelaReportForm(LimitSetting limitSetting, double azimuthA, double azimuthB, EMIFileData emiA, EMIFileData emiB, List<ChannelSetting> channelSettings)
{
InitializeComponent();
mLimitSetting = limitSetting;
mAzimuthA = azimuthA;
mAzimuthB = azimuthB;
mEmiA = emiA;
mEmiB = emiB;
mChannelSettings = channelSettings;
//int graphCount = mIniFile.ReadInt("General", "VenezuelaReportGraphCount", 1);
mExportStatusForm = new ExportStatusForm(this);
}
public MalaysiaReportForm(bool isFiveAzimuthReport, LimitSetting limitSetting, EMIFileData emiA, EMIFileData emiB, List<ChannelSetting> channelSettings)
{
InitializeComponent();
mIsFiveAzimuthReport = isFiveAzimuthReport;
mLimitSetting = limitSetting;
mEmiA = emiA;
mEmiB = emiB;
mChannelSettings = channelSettings;
EmiComboBox.Items.Add(mEmiA.Site_ID + " (User: "******", Time: " + mEmiA.PA_TestTime + ")");
EmiComboBox.Items.Add(mEmiB.Site_ID + " (User: "******", Time: " + mEmiB.PA_TestTime + ")");
mExportStatusForm = new ExportStatusForm(this);
}
public ReportForm(bool isFiveAzimuthReport, LimitSetting limitSetting, EMIFileData emiFileData, List<ChannelSetting> channelSettings)
{
InitializeComponent();
mIsFiveAzimuthReport = isFiveAzimuthReport;
mLimitSetting = limitSetting;
mEmiFileData = emiFileData;
mChannelSettings = channelSettings;
SiteIDLabel.Text = mEmiFileData.Site_ID;
SiteNameLabel.Text = mEmiFileData.Site_ID;
AddressLabel.Text = mEmiFileData.Site_Address;
DateLabel.Text = mEmiFileData.PA_TestTime;
EngineerLabel.Text = mEmiFileData.PA_UserName;
LongtitudeLabel.Text = Utility.ConvertLongtitude(mEmiFileData.Site_Longitude);
LatitudeLabel.Text = Utility.ConvertLatitude(mEmiFileData.Site_Longitude); ;
if (mLimitSetting.UseChannelPowerLimit)
PChannelLimitLabel.Text = mLimitSetting.ChannelPowerLimit.ToString();
else
PChannelLimitLabel.Text = "";
if (mLimitSetting.UseDeltaPowerLimit)
LevelLimitLabel.Text = mLimitSetting.DeltaPowerLimit.ToString();
else
LevelLimitLabel.Text = "";
if (mIniFile.ReadInt("General", "ChannelPreferred", 1) == 1)
ChannelPreferredRadioButton.Checked = true;
else
FrequencePreferredRadioButton.Checked = true;
DisplayChannelCheckBox.Enabled = (!ChannelPreferredRadioButton.Checked);
DisplayChannelCheckBox.Checked = (mIniFile.ReadInt("General", "DisplayChannel", 1) == 1);
SpanEditor.Text = mIniFile.ReadString("General", "Span", "300").Trim();
if (!Regex.IsMatch(SpanEditor.Text, @"^[1-9]\d*(\.\d+)?$"))
SpanEditor.Text = "300";
mDefaultStartFreq = channelSettings[0].StartFreq;
mDefaultEndFreq = channelSettings[channelSettings.Count -1].Pair.EndFreq;
SetDefaultFreq();
mExportStatusForm = new ExportStatusForm(this);
}
private static double FindClosestAzimuths(double angle, EMIFileData emiFileData)
{
List<AngleDiff> diffs = new List<AngleDiff>();
double diff;
HashSet<double> availableAngles = new HashSet<double>();
foreach (DG_Type dataGroup in emiFileData.DataGroups)
availableAngles.Add(dataGroup.DG_FB_Angle);
foreach (double availableAngle in availableAngles)
{
diff = Math.Min(Math.Abs(availableAngle - angle),
360 - Math.Abs(availableAngle - angle));
diffs.Add(new AngleDiff(availableAngle, diff));
}
diffs.Sort(AngleDiff.SortRountine);
return diffs[0].angle;
}
public MalaysiaMaxisReportForm(LimitSetting limitSetting,
EMIFileData emiFileData, List<ChannelSetting> channelSettings)
{
mLimitSetting = limitSetting;
mEmi = emiFileData;
string bandName;
foreach (ChannelSetting channelSetting in channelSettings)
{
bandName = GetBandName(channelSetting);
if (!mAllBandChannels.ContainsKey(bandName))
{
mAllBandChannels[bandName] = new List<ChannelSetting>();
}
mAllBandChannels[bandName].Add(channelSetting);
}
mEmiDataMgr = Utility.GetEmiDataManager(mEmi, channelSettings);
mExportStatusForm = new ExportStatusForm(this);
InitializeComponent();
}
public static BitMapInfo create(EMIFileData emi, double azimuth, double actualAzimuth,
string title, WatsEmiDataManager dataMgr,
List<ChannelSetting> channelSettings, LimitSetting limitSetting,
int minAbsRssi, int maxAbsRssi)
{
BitMapInfo bitMapInfo = new BitMapInfo();
List<WatsEmiSample> verticalSamples = new List<WatsEmiSample>();
List<WatsEmiSample> horizontalSamples = new List<WatsEmiSample>();
bitMapInfo.Title1 = title + " " + azimuth.ToString() + "\x00B0" + " V";
bitMapInfo.Title2 = title + " " + azimuth.ToString() + "\x00B0" + " H";
bitMapInfo.BmpFile1 = Utility.GetAppPath() + "\\Temp\\Site_" + emi.Site_ID + "_Azimuth_"
+ ((int)azimuth).ToString() + "_Vertical_" + (++counter).ToString() + ".emf";
bitMapInfo.BmpFile2 = Utility.GetAppPath() + "\\Temp\\Site_" + emi.Site_ID + "_Azimuth_"
+ ((int)azimuth).ToString() + "_Horizontal_" + (++counter).ToString() + ".emf";
for (int i = 0; i < dataMgr.AllSamples[actualAzimuth][0].Count; i++)
{
if (dataMgr.AllSamples[actualAzimuth][0][i].mFreq >= channelSettings[0].StartFreq
&& dataMgr.AllSamples[actualAzimuth][0][i].mFreq <= channelSettings[channelSettings.Count - 1].Pair.EndFreq)
verticalSamples.Add(dataMgr.AllSamples[actualAzimuth][0][i]);
}
for (int i = 0; i < dataMgr.AllSamples[actualAzimuth][1].Count; i++)
{
if (dataMgr.AllSamples[actualAzimuth][1][i].mFreq >= channelSettings[0].StartFreq
&& dataMgr.AllSamples[actualAzimuth][1][i].mFreq <= channelSettings[channelSettings.Count - 1].Pair.EndFreq)
horizontalSamples.Add(dataMgr.AllSamples[actualAzimuth][1][i]);
}
List<Marker> verticalMarkers = new List<Marker>();
List<Marker> hoizontalMarkers = new List<Marker>();
Marker marker;
ChannelPower channelPower;
foreach (ChannelSetting channelSetting in channelSettings)
{
channelPower = new ChannelPower(emi.SA_RBW, channelSetting, limitSetting, dataMgr.AllChannelSamples[actualAzimuth][channelSetting]);
if (!channelPower.IsValidVPower)
{
marker = Utility.CreateMarker(channelSetting.ChannelName, dataMgr.AllChannelSamples[actualAzimuth][channelSetting].mVSamples);
verticalMarkers.Add(marker);
}
if (!channelPower.IsValidVPairPower)
{
marker = Utility.CreateMarker(channelSetting.Pair.ChannelName, dataMgr.AllChannelSamples[actualAzimuth][channelSetting].mVPairSamples);
verticalMarkers.Add(marker);
}
if (!channelPower.IsValidHPower)
{
marker = Utility.CreateMarker(channelSetting.ChannelName, dataMgr.AllChannelSamples[actualAzimuth][channelSetting].mHSamples);
hoizontalMarkers.Add(marker);
}
if (!channelPower.IsValidHPairPower)
{
marker = Utility.CreateMarker(channelSetting.Pair.ChannelName, dataMgr.AllChannelSamples[actualAzimuth][channelSetting].mHPairSamples);
hoizontalMarkers.Add(marker);
}
}
verticalMarkers.Sort(Utility.SortMarkerByFrequency);
hoizontalMarkers.Sort(Utility.SortMarkerByFrequency);
drawPicture(emi, verticalSamples, channelSettings, limitSetting, bitMapInfo.BmpFile1, bitMapInfo.Title1, minAbsRssi, maxAbsRssi, verticalMarkers);
drawPicture(emi, horizontalSamples, channelSettings, limitSetting, bitMapInfo.BmpFile2, bitMapInfo.Title2, minAbsRssi, maxAbsRssi, hoizontalMarkers);
return bitMapInfo;
}
private static bool drawPicture(EMIFileData emi, List<WatsEmiSample> samples,
List<ChannelSetting> channels, LimitSetting limitSetting,
string picturePath, string title, int minAbsRssi, int maxAbsRssi, List<Marker> markers)
{
try
{
int height = 180 + (markers.Count + 1) * 15 + 6 * 15;
Bitmap bmp = new Bitmap(425, height);
Graphics gs = Graphics.FromImage(bmp);
Metafile mf = new Metafile(picturePath, gs.GetHdc());
Graphics g = Graphics.FromImage(mf);
double minX = channels[0].StartFreq;
double span = channels[channels.Count - 1].Pair.EndFreq - channels[0].StartFreq;
using (Brush bgBrush = new SolidBrush(Color.FromArgb(255, 255, 128)))
{
g.FillRectangle(bgBrush, 0, 0, 425, height);
}
using (Pen boldRectPen = new Pen(Color.Black, 2.0f))
{
g.DrawRectangle(boldRectPen, 0, 0, 425, height);
}
using (Pen boldRectPen = new Pen(Color.Black, 1.0f))
{
g.DrawRectangle(boldRectPen, 52, 15, 350, 130);
}
using (Pen gridPen = new Pen(Color.Gray, 0.5f))
{
gridPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
for (int j = 0; j < 9; j++)
g.DrawLine(gridPen, 52, 15 + (j + 1) * 13, 402, 15 + (j + 1) * 13);
for (int j = 0; j < 9; j++)
g.DrawLine(gridPen, 52 + (j + 1) * 35, 15, 52 + (j + 1) * 35, 145);
}
string text;
SizeF sizef;
RectangleF rf;
//drawing title
using (Font font = new Font("Times New Roman", 8.0f))
{
text = title;
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(227 - sizef.Width / 2, 10 - sizef.Height / 2, sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
}
//drawing side text
using (Font font = new Font("Times New Roman", 8.0f))
{
text = "Power (dBm)";
StringFormat sf = new StringFormat(StringFormatFlags.DirectionVertical);
sizef = g.MeasureString(text, font, Int32.MaxValue, sf);
rf = new RectangleF(5, 75 - sizef.Height / 2, sizef.Width, sizef.Height);
g.TranslateTransform((rf.Left + rf.Right) / 2, (rf.Top + rf.Bottom) / 2);
g.RotateTransform(180);
RectangleF newRf = new RectangleF(-sizef.Width / 2, -sizef.Height / 2, sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, newRf, sf);
g.ResetTransform();
}
//drawing bottom
using (Font font = new Font("Times New Roman", 8.0f))
{
text = "Frequency (MHz)";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(227 - sizef.Width / 2, 160, sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
}
//drawing x
using (Font font = new Font("Times New Roman", 5.0f))
{
List<string> xTexts = new List<string>();
int j;
for (j = 0; j < 11; j++)
xTexts.Add(Utility.ConvertDoubleString(minX + span * j / 10));
j = 0;
foreach (string xText in xTexts)
{
sizef = g.MeasureString(xText, font, Int32.MaxValue);
rf = new RectangleF(52 + j * 35 - sizef.Width / 2, 147,
sizef.Width, sizef.Height);
g.DrawString(xText, font, Brushes.Black, rf);
j++;
}
}
//drawing y
using (Font font = new Font("Times New Roman", 5.0f))
{
List<string> yTexts = new List<string>();
int j;
for (j = 0; j < 11; j++)
yTexts.Add("-" + (minAbsRssi + (maxAbsRssi - minAbsRssi) / 10 * j).ToString());
j = 0;
foreach (string yText in yTexts)
{
sizef = g.MeasureString(yText, font, Int32.MaxValue);
rf = new RectangleF(50 - sizef.Width, 15 + j * 13 - sizef.Height / 2,
sizef.Width, sizef.Height);
g.DrawString(yText, font, Brushes.Black, rf);
j++;
}
}
//drawing curve
using (Pen dataPen = new Pen(Color.Blue, 1.0f))
{
float x1, x2, y1, y2;
for (int j = 0; j < samples.Count - 1; j++)
{
x1 = (float)((samples[j].mFreq - minX) * 350 / span + 52);
y1 = (float)((Math.Abs(samples[j].mRssi) - minAbsRssi) * 130 / (maxAbsRssi - minAbsRssi) + 15);
x2 = (float)((samples[j + 1].mFreq - minX) * 350 / span + 52);
y2 = (float)((Math.Abs(samples[j + 1].mRssi) - minAbsRssi) * 130 / (maxAbsRssi - minAbsRssi) + 15);
g.DrawLine(dataPen, x1, y1, x2, y2);
}
}
//drawing bold separate line
using (Pen boldSeparateLinePen = new Pen(Color.Black, 2.0f))
{
g.DrawLine(boldSeparateLinePen, 0, 180, 425, 180);
g.DrawLine(boldSeparateLinePen, 0, 180 + (markers.Count + 1) * 15, 425, 180 + (markers.Count + 1) * 15);
}
using (Pen thinPen = new Pen(Color.Black, 1.0f))
{
using (Font font = new Font("Times New Roman", 7.0f))
{
//thin horizontal marking separate line
for (int j = 0; j < markers.Count; j++)
g.DrawLine(thinPen, 0, 180 + (j + 1) * 15, 425, 180 + (j + 1) * 15);
//thin vertical marking separate line
g.DrawLine(thinPen, 65, 180, 65, 180 + (markers.Count+ 1) * 15);
g.DrawLine(thinPen, 65 + 120, 180, 65 + 120, 180 + (markers.Count + 1) * 15);
g.DrawLine(thinPen, 65 + 240, 180, 65 + 240, 180 + (markers.Count + 1) * 15);
//marker titles
text = "Marker No.";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(5, 180 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = "Frequency (MHz)";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(65 + 5, 180 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = "RSSI (dBm)";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(185 + 5, 180 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = "Channel";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(305 + 5, 180 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
//marker no.
for (int j = 0; j < markers.Count; j++)
{
text = (j + 1).ToString();
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(5, 180 + (j + 1) * 15 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
}
//drawing mark
int i = 0;
foreach (Marker marker in markers)
{
text = Utility.ConvertDoubleString(marker.frequency);
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(65 + 5, 180 + (i + 1) * 15 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = marker.rssi.ToString();
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(185 + 5, 180 + (i + 1) * 15 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = marker.channelName;
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(305 + 5, 180 + (i + 1) * 15 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
drawMarker(g, minX, span, minAbsRssi, maxAbsRssi, marker);
i++;
}
//thin horizontal measurement separate line
for (int j = 0; j < 5; j++)
g.DrawLine(thinPen, 0, 180 + (markers.Count + 1) * 15 + (j + 1) * 15, 425, 180 + (markers.Count + 1) * 15 + (j + 1) * 15);
//thin vertical measurement separate line
g.DrawLine(thinPen, 90, 180 + (markers.Count + 1) * 15 + 15,
90, 180 + (markers.Count + 1) * 15 + 90);
g.DrawLine(thinPen, 90 + 112, 180 + (markers.Count + 1) * 15 + 15,
90 + 112, 180 + (markers.Count + 1) * 15 + 90);
g.DrawLine(thinPen, 90 + 112 + 90, 180 + (markers.Count + 1) * 15 + 15,
90 + 112 + 90, 180 + (markers.Count + 1) * 15 + 90);
//drawing measurement
text = "Measurement Parameter";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(209 - sizef.Width / 2, 180 + (markers.Count + 1) * 15.0f + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
/************************************************************************/
/* Center Frequency */
/************************************************************************/
text = "Center Frequency";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(5, 180 + (markers.Count + 1) * 15 + 15 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = Utility.ConvertDoubleString((channels[0].StartFreq + channels[channels.Count - 1].Pair.EndFreq) / 2000) + " GHz";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(90 + 5, 180 + (markers.Count + 1) * 15 + 15 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
/************************************************************************/
/* Span */
/************************************************************************/
text = "Span";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(202 + 5, 180 + (markers.Count + 1) * 15 + 15 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = Utility.ConvertDoubleString(channels[channels.Count - 1].Pair.EndFreq - channels[0].StartFreq) + " MHz";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(292 + 5, 180 + (markers.Count + 1) * 15 + 15 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
/************************************************************************/
/* Start Frequency */
/************************************************************************/
text = "Start Frequency";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(5, 180 + (markers.Count + 1) * 15 + 30 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = Utility.ConvertDoubleString(channels[0].StartFreq / 1000) + " GHz";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(90 + 5, 180 + (markers.Count + 1) * 15 + 30 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
/************************************************************************/
/* Stop Frequency */
/************************************************************************/
text = "Stop Frequency";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(202 + 5, 180 + (markers.Count + 1) * 15 + 30 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = Utility.ConvertDoubleString(channels[channels.Count - 1].Pair.EndFreq / 1000) + " GHz";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(292 + 5, 180 + (markers.Count + 1) * 15 + 30 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
/************************************************************************/
/* Reference Level */
/************************************************************************/
text = "Reference Level";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(5, 180 + (markers.Count + 1) * 15 + 45 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = Utility.ConvertDoubleString(emi.SA_REF_LEVEL) + " dBm";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(90 + 5, 180 + (markers.Count + 1) * 15 + 45 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
/************************************************************************/
/* Attenuation */
/************************************************************************/
text = "Attenuation";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(202 + 5, 180 + (markers.Count + 1) * 15 + 45 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = emi.SA_Attenuation_Value.ToString() + " dB";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(292 + 5, 180 + (markers.Count + 1) * 15 + 45 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
/************************************************************************/
/* RBW */
/************************************************************************/
text = "RBW";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(5, 180 + (markers.Count + 1) * 15 + 60 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = Utility.ConvertDoubleString(emi.SA_RBW) + " Hz";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(90 + 5, 180 + (markers.Count + 1) * 15 + 60 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
/************************************************************************/
/* VBW */
/************************************************************************/
text = "VBW";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(202 + 5, 180 + (markers.Count + 1) * 15 + 60 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = Utility.ConvertDoubleString(emi.SA_VBW) + " Hz";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(292 + 5, 180 + (markers.Count + 1) * 15 + 60 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
/************************************************************************/
/* Detection */
/************************************************************************/
text = "Detection";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(5, 180 + (markers.Count + 1) * 15 + 73 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = emi.SA_Detector;
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(90 + 5, 180 + (markers.Count + 1) * 15 + 73 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
/************************************************************************/
/* Mode */
/************************************************************************/
text = "Mode";
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(202 + 5, 180 + (markers.Count + 1) * 15 + 73 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
text = emi.SA_Sweep_Mode;
sizef = g.MeasureString(text, font, Int32.MaxValue);
rf = new RectangleF(292 + 5, 180 + (markers.Count + 1) * 15 + 73 + 3.5f,
sizef.Width, sizef.Height);
g.DrawString(text, font, Brushes.Black, rf);
}
}
g.Save();
g.Dispose();
}
catch (System.Exception e)
{
File.Delete("c:\\watsLog.txt");
FileStream fs = new FileStream("c:\\watsLog.txt", FileMode.CreateNew);
StreamWriter sw = new StreamWriter(fs);
sw.WriteLine(e.Message);
sw.WriteLine(e.StackTrace);
sw.Flush();
sw.Close();
fs.Close();
return false;
}
return true;
}
private void EMICombox_SelectedIndexChanged(object sender, EventArgs e)
{
mEmi = mEmiFileDatas[EMICombox.SelectedIndex];
}
public static WatsEmiDataManager GetEmiDataManager(EMIFileData emiFileData, List<ChannelSetting> channelSettings)
{
WatsEmiDataManager watsEmiDataManager = new WatsEmiDataManager();
Dictionary<double, double> startFrequencys = new Dictionary<double, double>();
Dictionary<double, double> endFrequencys = new Dictionary<double, double>();
Dictionary<ChannelSetting, WatsEmiData> datas;
Dictionary<int, List<WatsEmiSample>> samples = null;
ChannelSetting curChannelSetting;
WatsEmiData curData;
foreach (DG_Type dataGroup in emiFileData.DataGroups)
{
if (!startFrequencys.ContainsKey(dataGroup.DG_FB_Angle))
startFrequencys[dataGroup.DG_FB_Angle] = dataGroup.DG_FB_Start;
else if (dataGroup.DG_FB_Start < startFrequencys[dataGroup.DG_FB_Angle])
startFrequencys[dataGroup.DG_FB_Angle] = dataGroup.DG_FB_Start;
if (!endFrequencys.ContainsKey(dataGroup.DG_FB_Angle))
endFrequencys[dataGroup.DG_FB_Angle] = dataGroup.DG_FB_End;
else if (dataGroup.DG_FB_End > endFrequencys[dataGroup.DG_FB_Angle])
endFrequencys[dataGroup.DG_FB_Angle] = dataGroup.DG_FB_End;
if (!watsEmiDataManager.AllChannelSamples.TryGetValue(dataGroup.DG_FB_Angle, out datas))
{
datas = new Dictionary<ChannelSetting, WatsEmiData>();
watsEmiDataManager.AllChannelSamples.Add(dataGroup.DG_FB_Angle, datas);
}
if (!watsEmiDataManager.AllSamples.TryGetValue(dataGroup.DG_FB_Angle, out samples))
{
samples = new Dictionary<int, List<WatsEmiSample>>();
samples[0] = new List<WatsEmiSample>();
samples[1] = new List<WatsEmiSample>();
watsEmiDataManager.AllSamples.Add(dataGroup.DG_FB_Angle, samples);
}
foreach (DG_Data_Type data in dataGroup.DGDatas)
{
if (dataGroup.DB_FB_AntennaPolarization == 0)
samples[0].Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
else //if (dataGroup.DB_FB_AntennaPolarization == 1)
samples[1].Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
curChannelSetting = null;
foreach (ChannelSetting channelSetting in channelSettings)
{
if (data.DG_DI_Freq >= channelSetting.StartFreq
&& data.DG_DI_Freq <= channelSetting.EndFreq
|| data.DG_DI_Freq >= channelSetting.Pair.StartFreq
&& data.DG_DI_Freq <= channelSetting.Pair.EndFreq)
{
curChannelSetting = channelSetting;
break;
}
}
if (curChannelSetting == null)
continue;
if (!datas.TryGetValue(curChannelSetting, out curData))
{
curData = new WatsEmiData();
datas.Add(curChannelSetting, curData);
}
if (dataGroup.DB_FB_AntennaPolarization == 0)
{
if (data.DG_DI_Freq >= curChannelSetting.StartFreq
&& data.DG_DI_Freq <= curChannelSetting.EndFreq)
curData.mVSamples.Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
else
curData.mVPairSamples.Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
}
else
{
if (data.DG_DI_Freq >= curChannelSetting.StartFreq
&& data.DG_DI_Freq <= curChannelSetting.EndFreq)
curData.mHSamples.Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
else
curData.mHPairSamples.Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
}
}
}
SortEmiData(watsEmiDataManager);
return watsEmiDataManager;
}
private EmiAzimuthData GetEmiAzimuthData(EMIFileData emiData, double azimuth)
{
EmiAzimuthData emiAzimuthData = new EmiAzimuthData();
emiAzimuthData.Azimuth = azimuth;
emiAzimuthData.StartFreq = double.MaxValue;
emiAzimuthData.EndFreq = double.MinValue;
emiAzimuthData.HorizontalSamples = new List<WatsEmiSample>();
emiAzimuthData.VerticalSamples = new List<WatsEmiSample>();
emiAzimuthData.ChannelDatas = new Dictionary<ChannelSetting, WatsEmiData>();
ChannelSetting curChannelSetting;
WatsEmiData curData;
foreach (DG_Type dataGroup in emiData.DataGroups)
{
if (dataGroup.DG_FB_Angle != azimuth)
continue;
if (dataGroup.DG_FB_Start < emiAzimuthData.StartFreq)
emiAzimuthData.StartFreq = dataGroup.DG_FB_Start;
if (dataGroup.DG_FB_End > emiAzimuthData.EndFreq)
emiAzimuthData.EndFreq = dataGroup.DG_FB_End;
foreach (DG_Data_Type data in dataGroup.DGDatas)
{
if (dataGroup.DB_FB_AntennaPolarization == 0)
emiAzimuthData.VerticalSamples.Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
else //if (dataGroup.DB_FB_AntennaPolarization == 1)
emiAzimuthData.HorizontalSamples.Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
curChannelSetting = null;
foreach (ChannelSetting channelSetting in mChannelSettings)
{
if (data.DG_DI_Freq >= channelSetting.StartFreq
&& data.DG_DI_Freq <= channelSetting.EndFreq
|| data.DG_DI_Freq >= channelSetting.Pair.StartFreq
&& data.DG_DI_Freq <= channelSetting.Pair.EndFreq)
{
curChannelSetting = channelSetting;
break;
}
}
if (curChannelSetting == null)
continue;
if (!emiAzimuthData.ChannelDatas.TryGetValue(curChannelSetting, out curData))
{
curData = new WatsEmiData();
emiAzimuthData.ChannelDatas.Add(curChannelSetting, curData);
}
if (dataGroup.DB_FB_AntennaPolarization == 0)
{
if (data.DG_DI_Freq >= curChannelSetting.StartFreq
&& data.DG_DI_Freq <= curChannelSetting.EndFreq)
curData.mVSamples.Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
else
curData.mVPairSamples.Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
}
else
{
if (data.DG_DI_Freq >= curChannelSetting.StartFreq
&& data.DG_DI_Freq <= curChannelSetting.EndFreq)
curData.mHSamples.Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
else
curData.mHPairSamples.Add(new WatsEmiSample(data.DG_DI_Freq, data.DG_DI_RSSI));
}
}
}
return emiAzimuthData;
}
public static Dictionary<string, List<BitMapInfo>> create(EMIFileData emi,
double azimuth, string relativeAzimuth, WatsEmiDataManager dataMgr,
Dictionary<string, List<ChannelSetting>> allBandchannels, LimitSetting limitSetting,
int minAbsRssi, int maxAbsRssi)
{
Dictionary<string, List<BitMapInfo>> allChannelBitmapInfos = new Dictionary<string,List<BitMapInfo>>();
List<BitMapInfo> channelBitmapInfos;
BitMapInfo loBitMapInfo, hiBitMapInfo;
List<WatsEmiSample> loVerticalSamples, hiVerticalSamples;
List<WatsEmiSample> loHorizontalSamples, hiHorizontalSamples;
string bandName;
double curFreq;
int counter = 0;
List<BitMapInfo> channelBitmaps;
List<Marker> loVerticalMarkers, loHoizontalMarkers;
List<Marker> hiVerticalMarkers, hiHoizontalMarkers;
List<ChannelSetting> channelSettings;
List<ChannelSetting> pairChannelSettings;
Marker marker;
ChannelPower channelPower;
foreach (KeyValuePair<string, List<ChannelSetting>> pair in allBandchannels)
{
bandName = pair.Key;
channelBitmapInfos = new List<BitMapInfo>();
channelSettings = pair.Value;
pairChannelSettings = new List<ChannelSetting>();
foreach (ChannelSetting channelSetting in channelSettings)
pairChannelSettings.Add(channelSetting.Pair);
loVerticalSamples = new List<WatsEmiSample>();
for (int i = 0; i < dataMgr.AllSamples[azimuth][0].Count; i++)
{
curFreq = dataMgr.AllSamples[azimuth][0][i].mFreq;
if (curFreq >= channelSettings[0].StartFreq
&& curFreq <= channelSettings[channelSettings.Count - 1].EndFreq)
{
loVerticalSamples.Add(dataMgr.AllSamples[azimuth][0][i]);
}
}
loHorizontalSamples = new List<WatsEmiSample>();
for (int i = 0; i < dataMgr.AllSamples[azimuth][1].Count; i++)
{
curFreq = dataMgr.AllSamples[azimuth][1][i].mFreq;
if (curFreq >= channelSettings[0].StartFreq
&& curFreq <= channelSettings[channelSettings.Count - 1].EndFreq)
{
loHorizontalSamples.Add(dataMgr.AllSamples[azimuth][1][i]);
}
}
hiVerticalSamples = new List<WatsEmiSample>();
for (int i = 0; i < dataMgr.AllSamples[azimuth][0].Count; i++)
{
curFreq = dataMgr.AllSamples[azimuth][0][i].mFreq;
if (curFreq >= pairChannelSettings[0].StartFreq
&& curFreq <= pairChannelSettings[pairChannelSettings.Count - 1].EndFreq)
{
hiVerticalSamples.Add(dataMgr.AllSamples[azimuth][0][i]);
}
}
hiHorizontalSamples = new List<WatsEmiSample>();
for (int i = 0; i < dataMgr.AllSamples[azimuth][1].Count; i++)
{
curFreq = dataMgr.AllSamples[azimuth][1][i].mFreq;
if (curFreq >= pairChannelSettings[0].StartFreq
&& curFreq <= pairChannelSettings[pairChannelSettings.Count - 1].EndFreq)
{
hiHorizontalSamples.Add(dataMgr.AllSamples[azimuth][1][i]);
}
}
loBitMapInfo = new BitMapInfo();
loBitMapInfo.Title1 = "Spectrum Analyzer Data MDEF-LAXI_" + bandName + "_" + relativeAzimuth + "V (LO)";
loBitMapInfo.Title2 = "Spectrum Analyzer Data MDEF-LAXI_" + bandName + "_" + relativeAzimuth + "H (LO)";
loBitMapInfo.BmpFile1 = Utility.GetAppPath() + "\\Temp\\Site_" + emi.Site_ID + "_Azimuth_"
+ relativeAzimuth + "_" + bandName + "_LowBand_Vertical_" + (++counter).ToString() + ".emf";
loBitMapInfo.BmpFile2 = Utility.GetAppPath() + "\\Temp\\Site_" + emi.Site_ID + "_Azimuth_"
+ relativeAzimuth + "_" + bandName + "_LowBand_Horizontal_" + (counter).ToString() + ".emf";
hiBitMapInfo = new BitMapInfo();
hiBitMapInfo.Title1 = "Spectrum Analyzer DataMDEF-LAXI_" + bandName + "_" + relativeAzimuth + "V (HI)";
hiBitMapInfo.Title2 = "Spectrum Analyzer DataMDEF-LAXI_" + bandName + "_" + relativeAzimuth + "H (HI)";
hiBitMapInfo.BmpFile1 = Utility.GetAppPath() + "\\Temp\\Site_" + emi.Site_ID + "_Azimuth_"
+ relativeAzimuth + "_" + bandName + "_HighBand_Vertical_" + (++counter).ToString() + ".emf";
hiBitMapInfo.BmpFile2 = Utility.GetAppPath() + "\\Temp\\Site_" + emi.Site_ID + "_Azimuth_"
+ relativeAzimuth + "_" + bandName + "_HighBand_Horizontal_" + (counter).ToString() + ".emf";
loVerticalMarkers = new List<Marker>();
loHoizontalMarkers = new List<Marker>();
hiVerticalMarkers = new List<Marker>();
hiHoizontalMarkers = new List<Marker>();
foreach (ChannelSetting channelSetting in channelSettings)
{
channelPower = new ChannelPower(emi.SA_RBW, channelSetting, limitSetting, dataMgr.AllChannelSamples[azimuth][channelSetting]);
if (!channelPower.IsValidVPower)
{
marker = Utility.CreateMarker(channelSetting.ChannelName, dataMgr.AllChannelSamples[azimuth][channelSetting].mVSamples);
loVerticalMarkers.Add(marker);
}
if (!channelPower.IsValidVPairPower)
{
marker = Utility.CreateMarker(channelSetting.Pair.ChannelName, dataMgr.AllChannelSamples[azimuth][channelSetting].mVPairSamples);
hiVerticalMarkers.Add(marker);
}
if (!channelPower.IsValidHPower)
{
marker = Utility.CreateMarker(channelSetting.ChannelName, dataMgr.AllChannelSamples[azimuth][channelSetting].mHSamples);
loHoizontalMarkers.Add(marker);
}
if (!channelPower.IsValidHPairPower)
{
marker = Utility.CreateMarker(channelSetting.Pair.ChannelName, dataMgr.AllChannelSamples[azimuth][channelSetting].mHPairSamples);
hiHoizontalMarkers.Add(marker);
}
}
drawPicture(emi, loVerticalSamples, channelSettings, limitSetting, loBitMapInfo.BmpFile1, loBitMapInfo.Title1, minAbsRssi, maxAbsRssi, loVerticalMarkers);
drawPicture(emi, loHorizontalSamples, channelSettings, limitSetting, loBitMapInfo.BmpFile2, loBitMapInfo.Title2, minAbsRssi, maxAbsRssi, loHoizontalMarkers);
drawPicture(emi, hiVerticalSamples, pairChannelSettings, limitSetting, hiBitMapInfo.BmpFile1, hiBitMapInfo.Title1, minAbsRssi, maxAbsRssi, hiVerticalMarkers);
drawPicture(emi, hiHorizontalSamples, pairChannelSettings, limitSetting, hiBitMapInfo.BmpFile2, hiBitMapInfo.Title2, minAbsRssi, maxAbsRssi, hiHoizontalMarkers);
channelBitmaps = new List<BitMapInfo>();
channelBitmaps.Add(loBitMapInfo);
channelBitmaps.Add(hiBitMapInfo);
allChannelBitmapInfos[bandName] = channelBitmaps;
}
return allChannelBitmapInfos;
}
public EMIFileModel(EMIFileData data)
{
mEmiData = data;
}
public void Parse(string emiFileName, object context)
{
if (onParseFailed == null || onParseSuccessfully == null)
{
return;
}
new Thread(delegate()
{
using (FileStream fs = new FileStream(emiFileName, FileMode.Open, FileAccess.Read))
{
using (BinaryReader emiReader = new BinaryReader(fs))
{
EMIFileData emiFile = new EMIFileData();
try
{
byte[] FileFlag = emiReader.ReadBytes(8);
if (!EMIFileData.FileFlag.SequenceEqual(FileFlag))
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid FileFlag", context);
return;
}
emiFile.MajorVersion = emiReader.ReadUInt32();
emiFile.MinorVersion = emiReader.ReadUInt32();
emiFile.HeadLength = emiReader.ReadUInt32();
if (emiFile.HeadLength == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid HeadLength: 0", context);
return;
}
byte[] HeadContent = emiReader.ReadBytes((int)emiFile.HeadLength);
MemoryStream headContentMs = new MemoryStream(HeadContent);
using (BinaryReader headContentReader = new BinaryReader(headContentMs))
{
emiFile.HI_Base_Length = headContentReader.ReadUInt32();
if (emiFile.HI_Base_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid HI_Base_Length: 0", context);
return;
}
byte[] HI_Base_Contents = headContentReader.ReadBytes((int)emiFile.HI_Base_Length);
MemoryStream hiBaseContentsMs = new MemoryStream(HI_Base_Contents);
using (BinaryReader hiBaseContentsReader = new BinaryReader(hiBaseContentsMs))
{
/************************************************************************/
/* Program App */
/************************************************************************/
emiFile.Program_App_Length = hiBaseContentsReader.ReadUInt32();
if (emiFile.Program_App_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid Program_App_Length: 0", context);
return;
}
byte[] Program_App_Contents = hiBaseContentsReader.ReadBytes((int)emiFile.Program_App_Length);
MemoryStream programAppContentsMs = new MemoryStream(Program_App_Contents);
using (BinaryReader programAppContentsReader = new BinaryReader(programAppContentsMs))
{
emiFile.PA_Name = getUnicodeString(programAppContentsReader);
if (emiFile.PA_Name == null)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PA_Name", context);
return;
}
emiFile.PA_Version = getUnicodeString(programAppContentsReader);
if (emiFile.PA_Version == null)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PA_Version", context);
return;
}
emiFile.PA_TestTime = getUnicodeString(programAppContentsReader, 14);
if (emiFile.PA_TestTime == null)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PA_TestTime", context);
return;
}
emiFile.PA_UserName = getUnicodeString(programAppContentsReader);
if (emiFile.PA_UserName == null)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PA_UserName", context);
return;
}
emiFile.PA_DataFile = getUnicodeString(programAppContentsReader);
if (emiFile.PA_DataFile == null)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PA_DataFile", context);
return;
}
}
/************************************************************************/
/* Project INFO */
/************************************************************************/
emiFile.Project_Info_Length = hiBaseContentsReader.ReadUInt32();
if (emiFile.Project_Info_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid Project_Info_Length: 0", context);
return;
}
byte[] Project_Info_Contents = hiBaseContentsReader.ReadBytes((int)emiFile.Project_Info_Length);
MemoryStream projectInfoContentsMs = new MemoryStream(Project_Info_Contents);
using (BinaryReader projectInfoContentsReader = new BinaryReader(projectInfoContentsMs))
{
emiFile.PI_ID = getUnicodeString(projectInfoContentsReader);
if (emiFile.PI_ID == null)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PI_ID", context);
return;
}
emiFile.PI_TestMode = projectInfoContentsReader.ReadByte();
if (emiFile.PI_TestMode != 0 && emiFile.PI_TestMode != 1)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PI_TestMode " + emiFile.PI_TestMode, context);
return;
}
emiFile.PI_TestPriority = projectInfoContentsReader.ReadByte();
if (emiFile.PI_TestPriority != 0 && emiFile.PI_TestPriority != 1)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PI_TestPriority " + emiFile.PI_TestPriority, context);
return;
}
emiFile.PI_AntennaPolarization = projectInfoContentsReader.ReadByte();
if (emiFile.PI_AntennaPolarization != 0 && emiFile.PI_AntennaPolarization != 1
&& emiFile.PI_AntennaPolarization != 2 && emiFile.PI_AntennaPolarization != 3)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PI_AntennaPolarization " + emiFile.PI_AntennaPolarization, context);
return;
}
/************************************************************************/
/* Azimuth */
/************************************************************************/
emiFile.PI_Azimuth_Length = projectInfoContentsReader.ReadUInt32();
if (emiFile.PI_Azimuth_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PI_Azimuth_Length: 0", context);
return;
}
byte[] PI_Azimuth_Contents = projectInfoContentsReader.ReadBytes((int)emiFile.PI_Azimuth_Length);
MemoryStream pIAzimuthContentsMs = new MemoryStream(PI_Azimuth_Contents);
using (BinaryReader pIAzimuthContentsMsReader = new BinaryReader(pIAzimuthContentsMs))
{
emiFile.Azimuth_Item_Count = pIAzimuthContentsMsReader.ReadUInt32();
if (emiFile.Azimuth_Item_Count > 0)
emiFile.Azimuth_Data = new Azimuth_DATA_TYPE[emiFile.Azimuth_Item_Count];
for (int i = 0; i < emiFile.Azimuth_Item_Count; i++)
{
Azimuth_DATA_TYPE data = new Azimuth_DATA_TYPE();
data.Azimuth_Length = pIAzimuthContentsMsReader.ReadUInt32();
data.Azimuth_Start = pIAzimuthContentsMsReader.ReadDouble();
data.Azimuth_End = pIAzimuthContentsMsReader.ReadDouble();
data.Azimuth_Step = pIAzimuthContentsMsReader.ReadDouble();
emiFile.Azimuth_Data[i] = data;
}
}
/************************************************************************/
/* Frequency */
/************************************************************************/
emiFile.PI_Freq_Length = projectInfoContentsReader.ReadUInt32();
if (emiFile.PI_Freq_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PI_Freq_Length: 0", context);
return;
}
byte[] PI_Freq_Contents = projectInfoContentsReader.ReadBytes((int)emiFile.PI_Freq_Length);
MemoryStream pIFreqContentsMs = new MemoryStream(PI_Freq_Contents);
using (BinaryReader pIFreqContentsReader = new BinaryReader(pIFreqContentsMs))
{
emiFile.Freq_Item_Count = pIFreqContentsReader.ReadUInt32();
if (emiFile.Freq_Item_Count > 0)
emiFile.Frequency_Data = new Frequency_Data_Type[emiFile.Freq_Item_Count];
for (int i = 0; i < emiFile.Freq_Item_Count; i++)
{
Frequency_Data_Type data = new Frequency_Data_Type();
data.Frequency_Length = pIFreqContentsReader.ReadUInt32();
data.Frequency_ID = getUnicodeString(pIFreqContentsReader);
data.Frequency_Start = pIFreqContentsReader.ReadDouble();
data.Frequency_End = pIFreqContentsReader.ReadDouble();
data.Frequency_Comment = getUnicodeString(pIFreqContentsReader);
emiFile.Frequency_Data[i] = data;
}
}
/************************************************************************/
/* SA */
/************************************************************************/
emiFile.PI_SA_Length = projectInfoContentsReader.ReadUInt32();
if (emiFile.PI_SA_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PI_SA_Length: 0", context);
return;
}
byte[] PI_SA_Contents = projectInfoContentsReader.ReadBytes((int)emiFile.PI_SA_Length);
MemoryStream pISAContentsMs = new MemoryStream(PI_SA_Contents);
using (BinaryReader pISAContentsReader = new BinaryReader(pISAContentsMs))
{
emiFile.SA_ID = getUnicodeString(pISAContentsReader);
emiFile.SA_Span = pISAContentsReader.ReadDouble();
emiFile.SA_REF_LEVEL = pISAContentsReader.ReadDouble();
emiFile.SA_RBW = pISAContentsReader.ReadDouble();
emiFile.SA_VBW = pISAContentsReader.ReadDouble();
emiFile.SA_Detector = getUnicodeString(pISAContentsReader);
if (!"Positive".Equals(emiFile.SA_Detector) && !"RMS".Equals(emiFile.SA_Detector)
&& !"Negative".Equals(emiFile.SA_Detector) && !"Sample".Equals(emiFile.SA_Detector)
&& !"None".Equals(emiFile.SA_Detector))
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid SA_Detector: " + emiFile.SA_Detector, context);
return;
}
emiFile.SA_Trace = getUnicodeString(pISAContentsReader);
if (!"Normal".Equals(emiFile.SA_Trace) && !"Average".Equals(emiFile.SA_Trace)
&& !"Max Hold".Equals(emiFile.SA_Trace) && !"Min Hold".Equals(emiFile.SA_Trace)
&& !"None".Equals(emiFile.SA_Trace))
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid SA_Trace: " + emiFile.SA_Trace, context);
return;
}
emiFile.SA_Trace_Count = pISAContentsReader.ReadUInt16();
emiFile.SA_Filter = getUnicodeString(pISAContentsReader);
emiFile.SA_PreAmplify = getUnicodeString(pISAContentsReader);
if (!"ON".Equals(emiFile.SA_PreAmplify) && !"OFF".Equals(emiFile.SA_PreAmplify)
&& !"None".Equals(emiFile.SA_PreAmplify))
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid SA_PreAmplify: " + emiFile.SA_PreAmplify, context);
return;
}
emiFile.SA_Attenuation = getUnicodeString(pISAContentsReader);
if (!"Auto".Equals(emiFile.SA_Attenuation) && !"Assign".Equals(emiFile.SA_Attenuation))
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid SA_Attenuation: " + emiFile.SA_Attenuation, context);
return;
}
emiFile.SA_Attenuation_Value = pISAContentsReader.ReadByte();
emiFile.SA_Sweep_Mode = getUnicodeString(pISAContentsReader);
if (!"None".Equals(emiFile.SA_Sweep_Mode) && !"Fast".Equals(emiFile.SA_Sweep_Mode)
&& !"NO FFT".Equals(emiFile.SA_Sweep_Mode) && !"Performance".Equals(emiFile.SA_Sweep_Mode))
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid SA_Sweep_Mode: " + emiFile.SA_Sweep_Mode, context);
return;
}
}
/************************************************************************/
/* Device */
/************************************************************************/
emiFile.PI_Device_Length = projectInfoContentsReader.ReadUInt32();
if (emiFile.PI_Device_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PI_Device_Length: 0", context);
return;
}
byte[] PI_Device_Contents = projectInfoContentsReader.ReadBytes((int)emiFile.PI_Device_Length);
MemoryStream pIDeviceContentsMs = new MemoryStream(PI_Device_Contents);
using (BinaryReader pIDeviceContentsReader = new BinaryReader(pIDeviceContentsMs))
{
emiFile.Device_GPS_Length = pIDeviceContentsReader.ReadUInt32();
if (emiFile.Device_GPS_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid Device_GPS_Length: 0", context);
return;
}
emiFile.GPS_ID = getUnicodeString(pIDeviceContentsReader);
emiFile.Device_Compass_Length = pIDeviceContentsReader.ReadUInt32();
if (emiFile.Device_Compass_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid Device_Compass_Length: 0", context);
return;
}
emiFile.Compass_ID = getUnicodeString(pIDeviceContentsReader);
emiFile.Device_PT_Length = pIDeviceContentsReader.ReadUInt32();
if (emiFile.Device_PT_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid Device_PT_Length: 0", context);
return;
}
emiFile.PT_ID = getUnicodeString(pIDeviceContentsReader);
emiFile.Device_Antenna_Length = pIDeviceContentsReader.ReadUInt32();
if (emiFile.Device_Antenna_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid Device_Antenna_Length: 0", context);
return;
}
emiFile.Antenna_ID = getUnicodeString(pIDeviceContentsReader);
emiFile.Device_Cable_Length = pIDeviceContentsReader.ReadUInt32();
if (emiFile.Device_Cable_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid Device_Cable_Length: 0", context);
return;
}
emiFile.Cable_ID = getUnicodeString(pIDeviceContentsReader);
emiFile.Device_LNA_Length = pIDeviceContentsReader.ReadUInt32();
if (emiFile.Device_LNA_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid Device_LNA_Length: 0", context);
return;
}
emiFile.LNA_ID = getUnicodeString(pIDeviceContentsReader);
}
/************************************************************************/
/* Site */
/************************************************************************/
emiFile.PI_Site_Length = projectInfoContentsReader.ReadUInt32();
if (emiFile.PI_Site_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid PI_Site_Length: 0", context);
return;
}
byte[] PI_Site_Contents = projectInfoContentsReader.ReadBytes((int)emiFile.PI_Device_Length);
MemoryStream pISiteContentsMs = new MemoryStream(PI_Site_Contents);
using (BinaryReader pISiteContentsReader = new BinaryReader(pISiteContentsMs))
{
emiFile.Site_ID = getUnicodeString(pISiteContentsReader);
emiFile.Site_SerialNo = getUnicodeString(pISiteContentsReader);
emiFile.Site_Address = getUnicodeString(pISiteContentsReader);
emiFile.Site_Longitude = pISiteContentsReader.ReadDouble();
emiFile.Site_Latitude = pISiteContentsReader.ReadDouble();
emiFile.Site_Altitude = pISiteContentsReader.ReadDouble();
emiFile.Site_MagDeclination = pISiteContentsReader.ReadDouble();
emiFile.Site_CreateTime = getUnicodeString(pISiteContentsReader, 14);
emiFile.Site_Comment = getUnicodeString(pISiteContentsReader);
}
}
}
emiFile.HI_Extent_Length = headContentReader.ReadUInt32();
if (emiFile.HI_Extent_Length > 0)
{
byte[] HI_Extent_Contents = headContentReader.ReadBytes((int)emiFile.HI_Extent_Length);
}
}
/************************************************************************/
/* Data */
/************************************************************************/
emiFile.DataLength = emiReader.ReadUInt32();
if (emiFile.DataLength == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid DataLength: 0", context);
return;
}
byte[] Data_Contents = emiReader.ReadBytes((int)emiFile.DataLength);
MemoryStream dataContentsMs = new MemoryStream(Data_Contents);
using (BinaryReader dataContentReader = new BinaryReader(dataContentsMs))
{
emiFile.Data_Head_Length = dataContentReader.ReadUInt32();
if (emiFile.Data_Head_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "Invalid Data_Head_Length: 0", context);
return;
}
emiFile.DHI_DG_Count = dataContentReader.ReadUInt32();
if (emiFile.DHI_DG_Count > 0)
{
emiFile.DataGroups = new DG_Type[emiFile.DHI_DG_Count];
for (int i = 0; i < emiFile.DHI_DG_Count; i++)
{
DG_Type dataGroup = new DG_Type();
dataGroup.Data_Group_Length = dataContentReader.ReadUInt32();
dataGroup.DG_HI_Length = dataContentReader.ReadUInt32();
dataGroup.DG_FB_Start = dataContentReader.ReadDouble();
dataGroup.DG_FB_End = dataContentReader.ReadDouble();
dataGroup.DG_FB_Angle = dataContentReader.ReadDouble();
dataGroup.DB_FB_Antenna = getUnicodeString(dataContentReader);
dataGroup.DB_FB_AntennaPolarization = dataContentReader.ReadByte();
if (dataGroup.DB_FB_AntennaPolarization != 0 && dataGroup.DB_FB_AntennaPolarization != 1)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "DB_FB_AntennaPolarization: " + dataGroup.DB_FB_AntennaPolarization, context);
return;
}
dataGroup.DB_FB_TestTime = getUnicodeString(dataContentReader, 14);
//Ver2.3 or higher
if (emiFile.MajorVersion > 2
|| emiFile.MajorVersion == 2 && emiFile.MinorVersion >= 3)
{
dataGroup.DB_FB_Pic = getUnicodeString(dataContentReader);
}
dataGroup.DG_Item_Length = dataContentReader.ReadUInt32();
if (dataGroup.DG_Item_Length == 0)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, "DG_Item_Length: 0", context);
return;
}
dataGroup.DG_Item_Count = dataContentReader.ReadUInt32();
if (dataGroup.DG_Item_Count > 0)
dataGroup.DGDatas = new DG_Data_Type[dataGroup.DG_Item_Count];
for (int j = 0; j < dataGroup.DG_Item_Count; j++)
{
DG_Data_Type dgData = new DG_Data_Type();
dgData.DG_DI_RSSI = dataContentReader.ReadDouble();
dgData.DG_DI_Freq = dataContentReader.ReadDouble();
dataGroup.DGDatas[j] = dgData;
}
emiFile.DataGroups[i] = dataGroup;
}
}
}
mAttachedForm.BeginInvoke(onParseSuccessfully, emiFileName, emiFile, context);
}
catch (System.Exception e)
{
mAttachedForm.BeginInvoke(onParseFailed, emiFileName, e.Message, context);
}
}
}
}).Start();
}
public static List<BitMapInfo> create(EMIFileData emi, double azimuth,
string title, WatsEmiDataManager dataMgr,
List<ChannelSetting> channelSettings, LimitSetting limitSetting,
int minAbsRssi, int maxAbsRssi, double span, List<FrequencyRange> ranges,
ref string verticalCircleTitle, ref string horizontalCircleTitle,
ref string verticalCircleBmpFile, ref string horizontalCircleBmpFile)
{
List<BitMapInfo> bitMapInfos = new List<BitMapInfo>();
List<WatsEmiSample> verticalSamples;
List<WatsEmiSample> horizontalSamples;
verticalCircleBmpFile = Utility.GetAppPath() + "\\Temp\\" + azimuth.ToString() + "-circle-vertical.emf";
verticalCircleTitle = "V-" + azimuth.ToString() + "\x00B0["
+ ranges[0].FromFreq + "~" + ranges[ranges.Count - 1].EndFreq + " MHz]";
horizontalCircleBmpFile = Utility.GetAppPath() + "\\Temp\\" + azimuth.ToString() + "circle-horizontal.emf";
horizontalCircleTitle = "H-" + azimuth.ToString() + "\x00B0["
+ ranges[0].FromFreq + "~" + ranges[ranges.Count - 1].EndFreq + " MHz]";
//draw circle picture
drawCirclePicture(true, verticalCircleBmpFile, azimuth, 30, emi.SA_RBW, dataMgr.AllChannelSamples[azimuth], limitSetting);
drawCirclePicture(false, horizontalCircleBmpFile, azimuth, 30, emi.SA_RBW, dataMgr.AllChannelSamples[azimuth], limitSetting);
//calculate all Markers
List<Marker> allVerticalMarkers = new List<Marker>();
List<Marker> allHoizontalMarkers = new List<Marker>();
Marker marker;
ChannelPower channelPower;
foreach (ChannelSetting channelSetting in channelSettings)
{
channelPower = new ChannelPower(emi.SA_RBW, channelSetting, limitSetting, dataMgr.AllChannelSamples[azimuth][channelSetting]);
if (!channelPower.IsValidVPower)
{
marker = Utility.CreateMarker(channelSetting.ChannelName, dataMgr.AllChannelSamples[azimuth][channelSetting].mVSamples);
allVerticalMarkers.Add(marker);
}
if (!channelPower.IsValidVPairPower)
{
marker = Utility.CreateMarker(channelSetting.Pair.ChannelName, dataMgr.AllChannelSamples[azimuth][channelSetting].mVPairSamples);
allVerticalMarkers.Add(marker);
}
if (!channelPower.IsValidHPower)
{
marker = Utility.CreateMarker(channelSetting.ChannelName, dataMgr.AllChannelSamples[azimuth][channelSetting].mHSamples);
allHoizontalMarkers.Add(marker);
}
if (!channelPower.IsValidHPairPower)
{
marker = Utility.CreateMarker(channelSetting.Pair.ChannelName, dataMgr.AllChannelSamples[azimuth][channelSetting].mHPairSamples);
allHoizontalMarkers.Add(marker);
}
}
allVerticalMarkers.Sort(Utility.SortMarkerByFrequency);
allHoizontalMarkers.Sort(Utility.SortMarkerByFrequency);
//draw picture per range
BitMapInfo bitMapInfo;
List<Marker> verticalMarkers;
List<Marker> horizontalMarkers;
foreach (FrequencyRange range in ranges)
{
bitMapInfo = new BitMapInfo();
verticalSamples = new List<WatsEmiSample>();
horizontalSamples = new List<WatsEmiSample>();
verticalMarkers = new List<Marker>();
horizontalMarkers = new List<Marker>();
foreach (Marker rangeMarker in allVerticalMarkers)
{
if (rangeMarker.frequency >= range.FromFreq && rangeMarker.frequency <= range.EndFreq)
verticalMarkers.Add(rangeMarker);
}
foreach (Marker rangeMarker in allHoizontalMarkers)
{
if (rangeMarker.frequency >= range.FromFreq && rangeMarker.frequency <= range.EndFreq)
horizontalMarkers.Add(rangeMarker);
}
int markerRows = Math.Max(verticalMarkers.Count, horizontalMarkers.Count);
bitMapInfo.Band = Utility.ConvertDoubleString(range.FromFreq) + "-"
+ Utility.ConvertDoubleString(range.EndFreq);
bitMapInfo.Title1 = "V-" + Utility.ConvertDoubleString(azimuth) + "\x00B0"
+ "[" + Utility.ConvertDoubleString(range.FromFreq) + "~"
+ range.EndFreq
+ " MHz]";
bitMapInfo.Title2 = "H-" + Utility.ConvertDoubleString(azimuth) + "\x00B0"
+ "[" + Utility.ConvertDoubleString(range.FromFreq) + "~"
+ range.EndFreq
+ " MHz]";
bitMapInfo.BmpFile1 = Utility.GetAppPath() + "\\Temp\\Angle"
+ azimuth.ToString() + "-vertical-"
+ ((int)range.FromFreq).ToString() + ".emf";
bitMapInfo.BmpFile2 = Utility.GetAppPath() + "\\Temp\\Angle"
+ azimuth.ToString() + "-horizontal-"
+ ((int)range.FromFreq).ToString() + ".emf";
for (int i = 0; i < dataMgr.AllSamples[azimuth][0].Count; i++)
{
if (dataMgr.AllSamples[azimuth][0][i].mFreq >= range.FromFreq
&& dataMgr.AllSamples[azimuth][0][i].mFreq <= range.EndFreq)
verticalSamples.Add(dataMgr.AllSamples[azimuth][0][i]);
}
for (int i = 0; i < dataMgr.AllSamples[azimuth][1].Count; i++)
{
if (dataMgr.AllSamples[azimuth][1][i].mFreq >= range.FromFreq
&& dataMgr.AllSamples[azimuth][1][i].mFreq <= range.EndFreq)
horizontalSamples.Add(dataMgr.AllSamples[azimuth][1][i]);
}
drawPicture(emi, verticalSamples, span, range, limitSetting, bitMapInfo.BmpFile1, title + " V", minAbsRssi, maxAbsRssi, verticalMarkers, markerRows);
drawPicture(emi, horizontalSamples, span, range, limitSetting, bitMapInfo.BmpFile2, title + " H", minAbsRssi, maxAbsRssi, horizontalMarkers, markerRows);
bitMapInfos.Add(bitMapInfo);
}
return bitMapInfos;
}
void progressForm_OnEmiFileUploadHandler(EMIFileData emi)
{
mUploadedEmis.Add(emi);
}
void TestEMIParseForm_onParseSuccessfully(string emiName, EMIFileData emiFileData, object context)
{
MessageBox.Show(emiName + " parse successfully");
}
private void EMIComboxB_SelectedIndexChanged(object sender, EventArgs e)
{
if (EMIComboxA.SelectedIndex == -1
|| EMIComboxB.SelectedIndex == -1)
return;
AzimuthComboxA.Items.Clear();
AzimuthComboxB.Items.Clear();
if (EMIComboxA.SelectedIndex >= 0 && EMIComboxA.SelectedIndex == EMIComboxB.SelectedIndex)
{
MessageBox.Show("Can't select same EMI file !");
EMIComboxA.SelectedIndex = -1;
EMIComboxB.SelectedIndex = -1;
return;
}
mEmiA = mEmiFileDatas[EMIComboxA.SelectedIndex];
mEmiB = mEmiFileDatas[EMIComboxB.SelectedIndex];
if (!mIsOnlySitesSelectable)
CalculateAngle();
}
private void EMIComboxA_SelectedIndexChanged(object sender, EventArgs e)
{
if (EMIComboxA.SelectedIndex == -1
|| EMIComboxB.SelectedIndex == -1)
return;
AzimuthComboxA.Items.Clear();
AzimuthComboxB.Items.Clear();
if (EMIComboxA.SelectedIndex >= 0 && EMIComboxA.SelectedIndex == EMIComboxB.SelectedIndex)
{
MessageBox.Show("Can't select same EMI file !");
EMIComboxA.SelectedIndex = -1;
EMIComboxB.SelectedIndex = -1;
return;
}
if (mEmiFileDatas[EMIComboxA.SelectedIndex].Site_ID.
Equals(mEmiFileDatas[EMIComboxB.SelectedIndex].Site_ID, StringComparison.CurrentCultureIgnoreCase))
{
MessageBox.Show("Can't select EMI files of same site !");
EMIComboxA.SelectedIndex = -1;
EMIComboxB.SelectedIndex = -1;
return;
}
mEmiA = mEmiFileDatas[EMIComboxA.SelectedIndex];
mEmiB = mEmiFileDatas[EMIComboxB.SelectedIndex];
if (!mIsOnlySitesSelectable)
CalculateAngle();
}
private void OnAddEmiFile(string emiFile, EMIFileData emiData)
{
mUploadForm.AddEmiFile(emiFile, emiData);
}
private void AddEmiFile(string emiFile, EMIFileData emiData)
{
BeginInvoke(new AddEMIFileDelegate(OnAddEmiFile), emiFile, emiData);
}
void parser_onParseSuccessfully(string emiName, EMIFileData emiFileData, object context)
{
EMIFileParser parser = (EMIFileParser)context;
parser.onParseSuccessfully -= new EMIFileParser.parseSuccessfully(parser_onParseSuccessfully);
parser.onParseFailed -= new EMIFileParser.parseFailed(parser_onParseFailed);
mEmiFiles[emiName] = emiFileData;
if (!EMIFilesList.Items.Contains(emiName))
EMIFilesList.Items.Add(emiName);
if (EMIFilesList.Items.Count > 0)
EMIFilesList.SelectedIndex = 0;
StoreFileConfiguration();
}
private void EMIFileComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
EMIFileDetailButton.Enabled = (EMIFileComboBox.SelectedIndex >= 0);
if (EMIFileComboBox.SelectedIndex >= 0)
mEmiFileData = (EMIFileData)EMIFileComboBox.SelectedItem;
AnalysisButton.Enabled = (mEmiFileData != null && mChannelSettings != null);
}
public EMIDetailForm(EMIFileData emiData)
{
mEmiFileData = emiData;
InitializeComponent();
}
private void EmiComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (EmiComboBox.SelectedIndex == 0)
mCurEmi = mEmiA;
else
mCurEmi = mEmiB;
ShowSiteInformation();
AzimuthComboBox.Items.Clear();
List<double> azimuths;
if (EmiComboBox.SelectedIndex == 0)
azimuths = mAzimuthsA;
else
azimuths = mAzimuthsB;
foreach (double azimuth in azimuths)
{
AzimuthComboBox.Items.Add(azimuth);
if (AzimuthComboBox.Items.Count > 0)
{
AzimuthComboBox.SelectedIndex = 0;
}
}
ShowGraph();
}
