private void btnFilterSnapshotsBySunElevation_Click(object sender, EventArgs e)
{
theLogWindow = ServiceTools.LogAText(theLogWindow,
"=========== Processing started on " + DateTime.Now.ToString("s") + " ===========");
if (bgwSnapshotsFilteringWithSunElevation == null)
{
bgwSnapshotsFilteringWithSunElevation = new BackgroundWorker();
bgwSnapshotsFilteringWithSunElevation.WorkerSupportsCancellation = true;
bgwSnapshotsFilteringWithSunElevation.WorkerReportsProgress = true;
bgwSnapshotsFilteringWithSunElevation.DoWork += BgwSnapshotsFilteringWithSunElevation_DoWork;
bgwSnapshotsFilteringWithSunElevation.ProgressChanged += BgwSnapshotsFilteringWithSunElevation_ProgressChanged;
object[] args = new object[] { CopyImagesFrom_Path, ConcurrentDataXMLfilesPath, CopyImagesAndDataTo_Path };
bgwSnapshotsFilteringWithSunElevation.RunWorkerAsync(args);
ThreadSafeOperations.ToggleButtonState(btnFilterSnapshotsBySunElevation, true, "CANCEL", true);
}
else
{
if (bgwSnapshotsFilteringWithSunElevation.IsBusy)
{
bgwSnapshotsFilteringWithSunElevation.CancelAsync();
}
else
{
object[] args = new object[] { CopyImagesFrom_Path, ConcurrentDataXMLfilesPath, CopyImagesAndDataTo_Path };
bgwSnapshotsFilteringWithSunElevation.RunWorkerAsync(args);
ThreadSafeOperations.ToggleButtonState(btnFilterSnapshotsBySunElevation, true, "CANCEL", true);
}
}
}
private void btnToggleShowGraphs_Click(object sender, EventArgs e)
{
showGraphs = !showGraphs;
ThreadSafeOperations.ToggleButtonState(btnToggleShowGraphs, true, showGraphs ? "ON" : "OFF", true);
if (showGraphs)
{
if (timerGraphUpdate == null)
{
TimerCallback tcbRenderAndShowGraph = RenderAndShowGraph;
timerGraphUpdate = new System.Threading.Timer(tcbRenderAndShowGraph, null, 0, graphsUpdatingPeriodSec * 1000);
}
else
{
bgwGraphsPresenter.RunWorkerAsync();
}
//RenderAndShowGraph(null);
}
else
{
if (timerGraphUpdate != null)
{
timerGraphUpdate.Dispose();
}
}
}
private void btnConvert_Click(object sender, EventArgs e)
{
if ((bgwConvert != null) && (bgwConvert.IsBusy))
{
bgwConvert.CancelAsync();
return;
}
DoWorkEventHandler bgwConvert_DoWorkHandler = delegate(object currBGWsender, DoWorkEventArgs args)
{
BackgroundWorker selfWorker = currBGWsender as BackgroundWorker;
DirectoryInfo dInfo = new DirectoryInfo(strLogFilesDirectory);
FileInfo[] fInfoArr = dInfo.GetFiles("BcstLog-*.log");
int fInfoCounter = 0;
foreach (FileInfo fInfo in fInfoArr)
{
if (selfWorker.CancellationPending)
{
break;
}
// считать данные, запихнуть в один timeseries
}
// записать данные в файлы
};
RunWorkerCompletedEventHandler bgwConvert_CompletedHandler = delegate(object currBGWCompletedSender, RunWorkerCompletedEventArgs args)
{
ThreadSafeOperations.ToggleButtonState(btnProcessAccelerationTimeSeries, true, "CONVERT", false);
};
ProgressChangedEventHandler bgwConvert_ProgressChanged = delegate(object bgwDataReaderSender, ProgressChangedEventArgs args)
{
ThreadSafeOperations.UpdateProgressBar(prbConvertionProgress, args.ProgressPercentage);
};
ThreadSafeOperations.ToggleButtonState(btnConvert, true, "STOP", true);
bgwConvert = new BackgroundWorker();
bgwConvert.WorkerSupportsCancellation = true;
bgwConvert.WorkerReportsProgress = true;
bgwConvert.DoWork += bgwConvert_DoWorkHandler;
bgwConvert.RunWorkerCompleted += bgwConvert_CompletedHandler;
bgwConvert.ProgressChanged += bgwConvert_ProgressChanged;
//object[] bgwCalculateArgs = new object[] { imagesRepresentingForm };
object[] bgwConvertArgs = new object[] { };
bgwConvert.RunWorkerAsync(bgwConvertArgs);
}
//private void tbBcstListeningPort_TextChanged(object sender, EventArgs e)
//{
// portBcstRecvng = Convert.ToInt32(tbBcstListeningPort.Text);
//}
private void btnStartStopBdcstListening_Click(object sender, EventArgs e)
{
if (udpCatchingJob.IsBusy)
{
udpCatchingJob.CancelAsync();
}
else
{
udpCatchingJob.RunWorkerAsync();
StartUDPmessagesParser();
ThreadSafeOperations.ToggleButtonState(btnStartStopBdcstListening, true, "Stop listening", true);
}
}
private void bgwCopier_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Error != null)
{
theLogWindow = ServiceTools.LogAText(theLogWindow,
"ERROR has been caught: " + Environment.NewLine + e.Error.Message + Environment.NewLine);
//ThreadSafeOperations.SetTextTB(tbLog, "ERROR has been caught: " + Environment.NewLine, true);
//ThreadSafeOperations.SetTextTB(tbLog, e.Error.Message + Environment.NewLine, true);
}
//ThreadSafeOperations.SetTextTB(tbLog, "#007" + Environment.NewLine, true);
ThreadSafeOperations.UpdateProgressBar(prbUniversalProgress, 0);
theLogWindow = ServiceTools.LogAText(theLogWindow, "Finished work" + Environment.NewLine);
//ThreadSafeOperations.SetTextTB(tbLog, "Finished work" + Environment.NewLine, true);
ThreadSafeOperations.ToggleButtonState(btnDoWork, true, "SELECT", false);
}
private void btnDoWork_Click(object sender, EventArgs e)
{
theLogWindow = ServiceTools.LogAText(theLogWindow,
"=========== Processing started on " + DateTime.Now.ToString("s") + " ===========");
if (bgwCopier.IsBusy)
{
bgwCopier.CancelAsync();
}
else
{
object[] args = new object[] { CopyImagesFrom_Path, rtbConcurrentDataDir.Text, rtbToPath.Text, rtbGrIxYRGBstatsDir.Text };
bgwCopier.RunWorkerAsync(args);
ThreadSafeOperations.ToggleButtonState(btnDoWork, true, "CANCEL", true);
}
}
private void btnFindArduino_Click(object sender, EventArgs e)
{
if (arduinoBoardSearchingWorker.IsBusy)
{
arduinoBoardSearchingWorker.CancelAsync();
}
else
{
if (sender == btnFindArduino1)
{
needsToDiscoverArduinoBoardID1 = true;
}
else if (sender == btnFindArduino2)
{
needsToDiscoverArduinoBoardID2 = true;
}
ThreadSafeOperations.ToggleButtonState(btnFindArduino1, true, "CANCEL", true);
ThreadSafeOperations.ToggleButtonState(btnFindArduino2, true, "CANCEL", true);
arduinoBoardSearchingWorker.RunWorkerAsync();
}
}
private void button1_Click(object sender, EventArgs e)
{
if (bgwPlayingPresenter != null && bgwPlayingPresenter.IsBusy)
{
bgwPlayingPresenter.CancelAsync();
return;
}
if (accDeviationMagnitudeRenderer.verticalMarkersIndexesUsingXSpace.Count == 0)
{
return;
}
int currentDateTimeIndex = accDeviationMagnitudeRenderer.verticalMarkersIndexesUsingXSpace[0];
ThreadSafeOperations.ToggleButtonState(btnPlayStopAccAnimation, true, "STOP", true);
DoWorkEventHandler currDoWorkHandler = delegate(object currBGWsender, DoWorkEventArgs args)
{
BackgroundWorker selfworker = currBGWsender as BackgroundWorker;
SimpleVectorGraphics2D frontViewRenderer = new SimpleVectorGraphics2D(pbAccSideVisualization.Size);
frontViewRenderer.presentAxes = false;
frontViewRenderer.ptLeftTopSpaceCorner = new PointD(-5.0d, 0.0d);
frontViewRenderer.ptRightBottomSpaceCorner = new PointD(5.0d, -10.0d);
//frontViewRenderer.listVectorsToDraw.Add(DenseVector.OfEnumerable(new double[] {1.0d, -9.0d}));
//frontViewRenderer.listVectorsShift.Add(DenseVector.OfEnumerable(new double[] {0.0d, 0.0d}));
//frontViewRenderer.listVectColors.Add(new Bgr(Color.Blue));
//frontViewRenderer.Represent();
//ThreadSafeOperations.UpdatePictureBox(pbAccSideVisualization, frontViewRenderer.TheImage.Bitmap, false);
for (int i = currentDateTimeIndex; i < accDeviationMagnitudeRenderer.dvScatterXSpace[0].Count - 1; i++)
{
if (selfworker.CancellationPending)
{
break;
}
DateTime dtStartCalculate = DateTime.Now;
accDeviationMagnitudeRenderer.verticalMarkersList.Clear();
accDeviationMagnitudeRenderer.verticalMarkersList.Add(accDeviationMagnitudeRenderer.dvScatterXSpace[0][i]);
accDeviationMagnitudeRenderer.verticalMarkersIndexesUsingXSpace.Clear();
accDeviationMagnitudeRenderer.verticalMarkersIndexesUsingXSpace.Add(i);
accDeviationMagnitudeRenderer.RepresentMarkers();
ThreadSafeOperations.UpdatePictureBox(pbRepresentingDevMagnitude,
accDeviationMagnitudeRenderer.TheImage.Bitmap, false);
accDeviationAngleRenderer.verticalMarkersList.Clear();
accDeviationAngleRenderer.verticalMarkersList.Add(accDeviationAngleRenderer.dvScatterXSpace[0][i]);
accDeviationAngleRenderer.verticalMarkersIndexesUsingXSpace.Clear();
accDeviationAngleRenderer.verticalMarkersIndexesUsingXSpace.Add(i);
accDeviationAngleRenderer.RepresentMarkers();
ThreadSafeOperations.UpdatePictureBox(pbRepresentingDevAngle, accDeviationAngleRenderer.TheImage.Bitmap,
false);
accDeviationDirectionRenderer.verticalMarkersList.Clear();
accDeviationDirectionRenderer.verticalMarkersList.Add(accDeviationDirectionRenderer.dvScatterXSpace[0][i]);
accDeviationDirectionRenderer.verticalMarkersIndexesUsingXSpace.Clear();
accDeviationDirectionRenderer.verticalMarkersIndexesUsingXSpace.Add(i);
accDeviationDirectionRenderer.RepresentMarkers();
ThreadSafeOperations.UpdatePictureBox(pbRepresentingDevDirection, accDeviationDirectionRenderer.TheImage.Bitmap,
false);
frontViewRenderer.listVectorsToDraw.Clear();
frontViewRenderer.listVectorsShift.Clear();
frontViewRenderer.listVectColors.Clear();
//int globalArrayIndex = sensorsHistoryRepresentingScale + i-1;
DenseVector zeroValuesVect = DenseVector.OfEnumerable(new double[] { 0.0d, 0.0d });
DenseVector dvAccCalibrated = DenseVector.Create(3, idx => dmAccData[i, idx + 3]);
DenseVector dvAccCurrent = DenseVector.Create(3, idx => dmAccData[i, idx]);
AccelerometerData accCalibrated = new AccelerometerData(dvAccCalibrated);
accCalibrated.AccDoubleZ = -accCalibrated.AccDoubleZ;
AccelerometerData currAcc = new AccelerometerData(dvAccCurrent);
currAcc.AccDoubleZ = -currAcc.AccDoubleZ;
double koeffToRealGravity = 9.81d / accCalibrated.AccMagnitude;
accCalibrated = accCalibrated * koeffToRealGravity;
currAcc = currAcc * koeffToRealGravity;
AccelerometerData dAccCalibration = accCalibrated - (new AccelerometerData(0.0d, 0.0d, -9.81d));
currAcc = currAcc - dAccCalibration;
accCalibrated = accCalibrated - dAccCalibration;
frontViewRenderer.listVectorsToDraw.Add(DenseVector.OfEnumerable(new double[] { accCalibrated.xyProjectionMagnitude(), accCalibrated.AccDoubleZ }));
frontViewRenderer.listVectorsShift.Add(zeroValuesVect);
frontViewRenderer.listVectColors.Add(new Bgr(Color.Blue));
frontViewRenderer.listVectorsToDraw.Add(DenseVector.OfEnumerable(new double[] { currAcc.xyProjectionMagnitude(), currAcc.AccDoubleZ }));
frontViewRenderer.listVectorsShift.Add(zeroValuesVect);
frontViewRenderer.listVectColors.Add(new Bgr(Color.Red));
frontViewRenderer.Represent();
ThreadSafeOperations.UpdatePictureBox(pbAccSideVisualization, frontViewRenderer.TheImage.Bitmap, false);
TimeSpan dtCalculationTime = DateTime.Now - dtStartCalculate;
double timeToWait = (accDeviationDirectionRenderer.dvScatterXSpace[0][i + 1] -
accDeviationDirectionRenderer.dvScatterXSpace[0][i]) * 1000.0d
- (double)(dtCalculationTime.TotalMilliseconds);
if (timeToWait > 0)
{
//System.Windows.Forms.Application.DoEvents();
Thread.Sleep(Convert.ToInt32(timeToWait));
}
}
};
RunWorkerCompletedEventHandler currWorkCompletedHandler =
delegate(object currBGWCompletedSender, RunWorkerCompletedEventArgs args)
{
ThreadSafeOperations.ToggleButtonState(btnPlayStopAccAnimation, true, "PLAY", true);
};
bgwPlayingPresenter = new BackgroundWorker();
bgwPlayingPresenter.WorkerSupportsCancellation = true;
bgwPlayingPresenter.DoWork += currDoWorkHandler;
bgwPlayingPresenter.RunWorkerCompleted += currWorkCompletedHandler;
object[] BGWargs = new object[] { "", "" };
bgwPlayingPresenter.RunWorkerAsync(BGWargs);
}
private void arduinoBoardSearchingWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
ThreadSafeOperations.ToggleButtonState(btnFindArduino1, true, "search for board (ID=1)", false);
ThreadSafeOperations.ToggleButtonState(btnFindArduino2, true, "search for board (ID=2)", false);
}
private void udpCatchingJob_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
ThreadSafeOperations.ToggleButtonState(btnStartStopBdcstListening, true, "Start listening", false);
bgwUDPmessagesParser.CancelAsync();
}
private void btnProcessAccelerationTimeSeries_Click(object sender, EventArgs e)
{
if ((bgwCalculate != null) && (bgwCalculate.IsBusy))
{
bgwCalculate.CancelAsync();
return;
}
//simpleMultipleImagesShow imagesRepresentingForm = new simpleMultipleImagesShow();
//imagesRepresentingForm.Show();
DoWorkEventHandler bgwCalculate_DoWorkHandler = delegate(object currBGWsender, DoWorkEventArgs args)
{
BackgroundWorker selfWorker = currBGWsender as BackgroundWorker;
//simpleMultipleImagesShow multImagesRepresentingForm = (simpleMultipleImagesShow)((args.Argument as object[])[0]);
//Type theShowImagesType = multImagesRepresentingForm.GetType();
//MethodInfo thePicturePlacingMethodInfo = theShowImagesType.GetMethod("PlaceAPicture");
int imageRepresentingCounter = 0;
DateTime dbgDT = new DateTime(2014, 7, 9, 9, 0, 0);
dbgDT = dbgDT.AddMinutes(33);
DateTime dtSeriesStart = accSubseries[0].StartTime;
double tsOverallSeriesDurationMillisec = (accSubseries[accSubseries.Count - 1].EndTime - accSubseries[0].StartTime).TotalMilliseconds;
string strToWrite = " fileName ; lat ; lon ; date ; time ; time(s) since start ; period(s) ; spectrum amplitude";
ServiceTools.logToTextFile(strOutputDirectory + "\\100sData-spectra-maximums.dat", strToWrite + Environment.NewLine, true);
foreach (TimeSeries <double> accSubseria in accSubseries)
{
if (selfWorker.CancellationPending)
{
break;
}
int startindex = 0;
while (true)
{
int endIndex;
if (selfWorker.CancellationPending)
{
break;
}
TimeSeries <double> currTimeSeria = accSubseria.SubSeria(startindex, new TimeSpan(1000000000),
out endIndex); //100s
currTimeSeria = currTimeSeria.InterpolateSeria(new TimeSpan(500000));
currTimeSeria = currTimeSeria.ExtractDataDeviationValues();
//обработать и оценить наличие выраженных периодов
Complex[] sourceSignalArray = currTimeSeria.DataRealValuesComplexArray();
Fourier.Forward(sourceSignalArray);
//Transform.FourierForward(sourceSignalArray);
List <Complex> FourierTransformedSignal = new List <Complex>(sourceSignalArray);
List <double> FourierTransformedSignalAmplitudes =
FourierTransformedSignal.ConvertAll <double>(
cVal =>
((double.IsNaN(cVal.Magnitude)) || (double.IsInfinity(cVal.Magnitude)))
? (0.0d)
: (cVal.Magnitude));
List <double> FourierTransformedSignalPeriods = new List <double>();
for (int ind = 0; ind < FourierTransformedSignalAmplitudes.Count; ind++)
{
FourierTransformedSignalPeriods.Add(currTimeSeria.TotalSeriaDuration.TotalSeconds /
(double)ind);
}
FourierTransformedSignalAmplitudes =
new List <double>(
FourierTransformedSignalAmplitudes.Zip <double, double, double>(
FourierTransformedSignalPeriods,
(amp, periodSec) =>
((double.IsNaN(periodSec)) || (double.IsInfinity(periodSec))) ? (0.0d) : (amp)));
FourierTransformedSignalPeriods =
FourierTransformedSignalPeriods.ConvertAll <double>(
dval => ((double.IsNaN(dval)) || (double.IsInfinity(dval))) ? (0.0d) : (dval));
//проанализируем этот участок - есть ли выраженные пики по амплитуде конкретных частот
//найти максимум в спектре и выдать данные об этом максимуме в файл
// сначала отфильтруем периоды меньше 1с - для данных по динамике судна они несущественны
FourierTransformedSignalAmplitudes =
new List <double>(
FourierTransformedSignalAmplitudes.Zip <double, double, double>(
FourierTransformedSignalPeriods,
(amp, periodSec) => (periodSec <= 1.0d) ? (0.0d) : (amp)));
FourierTransformedSignalPeriods =
FourierTransformedSignalPeriods.ConvertAll <double>(dVal => (dVal <= 1.0d) ? (0.0d) : (dVal));
DescriptiveStatistics currAmpsStat =
new DescriptiveStatistics(FourierTransformedSignalAmplitudes);
List <double> lAmpsOutstanding = FourierTransformedSignalAmplitudes.ConvertAll <double>(dVal =>
{
if (dVal / currAmpsStat.Mean >= 100.0d)
{
return(dVal);
}
return(0.0d);
});
List <double> lPeriodsOutstanding =
new List <double>(FourierTransformedSignalPeriods.Zip <double, double, double>(lAmpsOutstanding,
(per, amp) => (amp == 0.0d) ? (0.0d) : (per)));
if (lAmpsOutstanding.Sum() > 0.0d)
{
MultipleScatterAndFunctionsRepresentation renderer =
new MultipleScatterAndFunctionsRepresentation(2048, 1536);
renderer.dvScatterXSpace.Add(currTimeSeria.TimeStampsValuesSeconds);
renderer.dvScatterFuncValues.Add(currTimeSeria.dvDoubleDataValues);
renderer.scatterLineColors.Add(new Bgr(255, 50, 50));
renderer.scatterDrawingVariants.Add(SequencesDrawingVariants.polyline);
renderer.dvScatterXSpace.Add(DenseVector.OfEnumerable(FourierTransformedSignalPeriods));
renderer.dvScatterFuncValues.Add(DenseVector.OfEnumerable(FourierTransformedSignalAmplitudes));
renderer.scatterLineColors.Add(new Bgr(50, 255, 50));
renderer.scatterDrawingVariants.Add(SequencesDrawingVariants.squares);
renderer.dvScatterXSpace.Add(DenseVector.OfEnumerable(lPeriodsOutstanding));
renderer.dvScatterFuncValues.Add(DenseVector.OfEnumerable(lAmpsOutstanding));
renderer.scatterLineColors.Add(new Bgr(50, 50, 255));
renderer.scatterDrawingVariants.Add(SequencesDrawingVariants.circles);
renderer.Represent();
if (strOutputDirectory != "")
{
double maxAmp = lAmpsOutstanding.Max();
int idx = lAmpsOutstanding.FindIndex(dval => dval == maxAmp);
double maxAmpPeriod = lPeriodsOutstanding[idx];
GPSdata gpsMark = gpsSeriaData.GetMostClose(currTimeSeria.StartTime).Item2;
string fName = currTimeSeria.StartTime.ToString("s").Replace(":", "-") +
"-100sData-spectrum.jpg";
renderer.SaveToImage(strOutputDirectory + "\\" + fName, true);
strToWrite = "" + fName + " ; ";
strToWrite += gpsMark.LatDec + " ; ";
strToWrite += gpsMark.LonDec + " ; ";
strToWrite += currTimeSeria.StartTime.Date.ToString("yyyy-MM-dd") + " ; ";
strToWrite += currTimeSeria.StartTime.ToString("HH-mm-ss") + " ; ";
strToWrite += (currTimeSeria.StartTime - dtSeriesStart).TotalSeconds + " ; ";
strToWrite += maxAmpPeriod.ToString() + " ; ";
strToWrite += maxAmp.ToString() + " ; ";
ServiceTools.logToTextFile(strOutputDirectory + "\\100sData-spectra-maximums.dat", strToWrite + Environment.NewLine, true);
ThreadSafeOperations.SetText(lblStatusString, "processing: " + currTimeSeria.StartTime.ToString("s"), false);
}
}
if ((currTimeSeria.StartTime >= dbgDT) || (currTimeSeria.EndTime >= dbgDT))
{
startindex++;
startindex--;
}
if (endIndex == accSubseria.Count - 1)
{
break;
}
Application.DoEvents();
selfWorker.ReportProgress(Convert.ToInt32(100.0d * (currTimeSeria.EndTime - dtSeriesStart).TotalMilliseconds / tsOverallSeriesDurationMillisec));
startindex += Convert.ToInt32((endIndex - startindex) / 2.0d);
}
}
};
RunWorkerCompletedEventHandler bgwCalculate_CompletedHandler = delegate(object currBGWCompletedSender, RunWorkerCompletedEventArgs args)
{
ThreadSafeOperations.ToggleButtonState(btnProcessAccelerationTimeSeries, true, "Process acceleration timeseries", false);
};
ProgressChangedEventHandler bgwCalculate_ProgressChanged = delegate(object bgwDataReaderSender, ProgressChangedEventArgs args)
{
ThreadSafeOperations.UpdateProgressBar(prbReadingProcessingData, args.ProgressPercentage);
};
ThreadSafeOperations.ToggleButtonState(btnProcessAccelerationTimeSeries, true, "STOP", true);
bgwCalculate = new BackgroundWorker();
bgwCalculate.WorkerSupportsCancellation = true;
bgwCalculate.WorkerReportsProgress = true;
bgwCalculate.DoWork += bgwCalculate_DoWorkHandler;
bgwCalculate.RunWorkerCompleted += bgwCalculate_CompletedHandler;
bgwCalculate.ProgressChanged += bgwCalculate_ProgressChanged;
//object[] bgwCalculateArgs = new object[] { imagesRepresentingForm };
object[] bgwCalculateArgs = new object[] { };
bgwCalculate.RunWorkerAsync(bgwCalculateArgs);
}
private void btnReadData_Click(object sender, EventArgs e)
{
strLogFilesDirectory = tbLogFilesPath.Text;
if (bgwDataReader != null && bgwDataReader.IsBusy)
{
bgwDataReader.CancelAsync();
return;
}
ThreadSafeOperations.ToggleButtonState(btnReadData, true, "CANCEL", true);
DoWorkEventHandler currDoWorkHandler = delegate(object currBGWsender, DoWorkEventArgs args)
{
BackgroundWorker selfworker = currBGWsender as BackgroundWorker;
List <double> lTotalDataToAdd = new List <double>();
List <DateTime> lDateTimeList = new List <DateTime>();
DirectoryInfo dInfo = new DirectoryInfo(strLogFilesDirectory);
FileInfo[] fInfoArr = dInfo.GetFiles("*AccelerometerDataLog*.nc");
int fInfoCounter = 0;
foreach (FileInfo fInfo in fInfoArr)
{
if (selfworker.CancellationPending)
{
break;
}
fInfoCounter++;
selfworker.ReportProgress(Convert.ToInt32((double)(fInfoCounter - 1) / (double)fInfoArr.Length));
ThreadSafeOperations.SetText(lblStatusString, "reading " + fInfo.FullName, false);
Dictionary <string, object> dictDataLoaded = NetCDFoperations.ReadDataFromFile(fInfo.FullName);
string varNameDateTime = "DateTime";
if (dictDataLoaded.Keys.Contains("DateTime"))
{
varNameDateTime = "DateTime";
}
else if (dictDataLoaded.Keys.Contains("Datetime"))
{
varNameDateTime = "Datetime";
}
List <long> currFileDateTimeLongTicksList = new List <long>((dictDataLoaded[varNameDateTime] as long[]));
List <DateTime> currFileDateTimeList = currFileDateTimeLongTicksList.ConvertAll(longVal => new DateTime(longVal));
string varNameAccData = "AccelerometerData";
List <AccelerometerData> lAccData = AccelerometerData.OfDenseMatrix(dictDataLoaded[varNameAccData] as DenseMatrix);
List <double> lAccDataToAdd = lAccData.ConvertAll <double>(acc => acc.AccMagnitude);
lTotalDataToAdd.AddRange(lAccDataToAdd);
lDateTimeList.AddRange(currFileDateTimeList);
selfworker.ReportProgress(Convert.ToInt32((double)(fInfoCounter) / (double)fInfoArr.Length));
}
accSeriaData.AddSubseriaData(lTotalDataToAdd, lDateTimeList);
//теперь обработаем считанные данные
ThreadSafeOperations.SetText(lblStatusString, "basic acceleration data processing...", false);
accSubseries = accSeriaData.SplitWithTimeSpanCondition(dt => dt.TotalMilliseconds >= 1200);
accSubseries.RemoveAll(theSeria => theSeria.TotalSeriaDuration.TotalSeconds < 100);
List <double> listSeriesStats =
accSubseries.ConvertAll(timeseria => timeseria.TotalSeriaDuration.TotalSeconds);
DescriptiveStatistics stats = new DescriptiveStatistics(listSeriesStats);
string strToShow = "Acceleration data start time: " + accSubseries[0].StartTime.ToString("s") + Environment.NewLine;
strToShow += "Acceleration data end time: " + accSubseries[accSubseries.Count - 1].EndTime.ToString("s") + Environment.NewLine;
strToShow += "total chunks count: " + accSubseries.Count + Environment.NewLine;
strToShow += "mean chunk duration: " + stats.Mean.ToString("0.##e-00") + " s" + Environment.NewLine;
strToShow += "min chunk duration: " + stats.Minimum.ToString("0.##e-00") + " s" + Environment.NewLine;
strToShow += "max chunk duration: " + stats.Maximum.ToString("0.##e-00") + " s" + Environment.NewLine;
strToShow += "StdDev of chunk duration: " + stats.StandardDeviation.ToString("0.##e-00") + " s" + Environment.NewLine;
ThreadSafeOperations.SetTextTB(tbReportLog, strToShow, true);
List <GPSdata> lTotalGPSDataToAdd = new List <GPSdata>();
List <DateTime> lGPSDateTimeList = new List <DateTime>();
dInfo = new DirectoryInfo(strLogFilesDirectory);
fInfoArr = dInfo.GetFiles("*GPSDataLog*.nc");
fInfoCounter = 0;
foreach (FileInfo fInfo in fInfoArr)
{
if (selfworker.CancellationPending)
{
break;
}
fInfoCounter++;
selfworker.ReportProgress(Convert.ToInt32((double)(fInfoCounter - 1) / (double)fInfoArr.Length));
ThreadSafeOperations.SetText(lblStatusString, "reading " + fInfo.FullName, false);
Dictionary <string, object> dictDataLoaded = NetCDFoperations.ReadDataFromFile(fInfo.FullName);
string varNameDateTime = "DateTime";
if (dictDataLoaded.Keys.Contains("DateTime"))
{
varNameDateTime = "DateTime";
}
else if (dictDataLoaded.Keys.Contains("Datetime"))
{
varNameDateTime = "Datetime";
}
List <long> currFileDateTimeLongTicksList = new List <long>((dictDataLoaded[varNameDateTime] as long[]));
List <DateTime> currFileDateTimeList = currFileDateTimeLongTicksList.ConvertAll(longVal => new DateTime(longVal));
string varNameGPSData = "GPSdata";
List <GPSdata> lGPSData = GPSdata.OfDenseMatrix(dictDataLoaded[varNameGPSData] as DenseMatrix);
//List<double> lGPSDataToAdd = lGPSData.ConvertAll<double>(acc => acc.AccMagnitude);
lTotalGPSDataToAdd.AddRange(lGPSData);
lGPSDateTimeList.AddRange(currFileDateTimeList);
selfworker.ReportProgress(Convert.ToInt32((double)(fInfoCounter) / (double)fInfoArr.Length));
}
gpsSeriaData.AddSubseriaData(lTotalGPSDataToAdd, lGPSDateTimeList);
//теперь обработаем считанные данные
ThreadSafeOperations.SetText(lblStatusString, "basic GPS data processing...", false);
gpsSeriaData.RemoveValues(gpsDatum => ((gpsDatum.lat == 0.0d) && (gpsDatum.lon == 0.0d)));
gpsSeriaData.RemoveDuplicatedTimeStamps();
strToShow = Environment.NewLine + "GPS data start time: " + gpsSeriaData.StartTime.ToString("s") + Environment.NewLine;
strToShow += "GPS data end time: " + gpsSeriaData.EndTime.ToString("s") + Environment.NewLine;
ThreadSafeOperations.SetTextTB(tbReportLog, strToShow, true);
};
RunWorkerCompletedEventHandler currWorkCompletedHandler = delegate(object currBGWCompletedSender, RunWorkerCompletedEventArgs args)
{
ThreadSafeOperations.ToggleButtonState(btnReadData, true, "Read data", true);
};
ProgressChangedEventHandler bgwDataReader_ProgressChanged = delegate(object bgwDataReaderSender, ProgressChangedEventArgs args)
{
ThreadSafeOperations.UpdateProgressBar(prbReadingProcessingData, args.ProgressPercentage);
};
bgwDataReader = new BackgroundWorker();
bgwDataReader.WorkerSupportsCancellation = true;
bgwDataReader.WorkerReportsProgress = true;
bgwDataReader.DoWork += currDoWorkHandler;
bgwDataReader.RunWorkerCompleted += currWorkCompletedHandler;
bgwDataReader.ProgressChanged += bgwDataReader_ProgressChanged;
object[] BGWargs = new object[] { "", "" };
bgwDataReader.RunWorkerAsync(BGWargs);
}