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(); }