private void pictureBox1_MouseClick(object sender, MouseEventArgs e)
{
Point MousePos = e.Location;
double xd = (double)LocalBitmap2show.Width * (double)MousePos.X / (double)SetImageWidth;
double yd = (double)LocalBitmap2show.Height * (double)MousePos.Y / (double)SetImageHeight;
int x = (int)Math.Round(xd);
int y = (int)Math.Round(yd);
string Str2Show = "x = " + x.ToString() + "; y = " + y.ToString() + "; ";
if (ObjDetector != null)
{
Str2Show += "SIval = " + Math.Round(ObjDetector.DetectedObjects[x][y].SIvalue, 2).ToString() + "; ";
Str2Show += "IsCloud = " + ObjDetector.DetectedObjects[x][y].IsCloud.ToString() + "; ";
Str2Show += "ObjID = " + ObjDetector.DetectedObjects[x][y].ObjID.ToString() + "; ";
}
ThreadSafeOperations.SetText(label1, Str2Show, false);
}
private void RepresentData()
{
ThreadSafeOperations.SetText(lblFileName, dataFileName, false);
ILInArray <double> dataValues = dmDataToShow.ToArray();
ILScene scene = new ILScene();
ILPlotCube currSurfPlotCube = new ILPlotCube();
currSurfPlotCube.TwoDMode = false;
ILSurface surf = new ILSurface(dataValues);
surf.UseLighting = true;
surf.Colormap = Colormaps.Jet;
surf.Children.Add(new ILColorbar());
currSurfPlotCube.Children.Add(surf);
currSurfPlotCube.Rotation = Matrix4.Rotation(new Vector3(1, 0, 0), 1.2f) *
Matrix4.Rotation(new Vector3(0, 0, 1), Math.PI);
currSurfPlotCube.Projection = Projection.Perspective;
scene.Add(currSurfPlotCube);
//scene.First<ILSurface>().MouseClick += (s, arg) =>
//{
// // we start at the mouse event target -> this will be the
// // surface group node (the parent of "Fill" and "Wireframe")
// var group = arg.Target.Parent;
// if (group != null)
// {
// // walk up to the next camera node
// Matrix4 trans = group.Transform;
// while (!(group is ILCamera) && group != null)
// {
// group = group.Parent;
// // collect all nodes on the path up
// trans = group.Transform * trans;
// }
// if (group != null && (group is ILCamera))
// {
// // convert args.LocationF to world coords
// // The Z coord is not provided by the mouse! -> choose arbitrary value
// var pos = new Vector3(arg.LocationF.X * 2 - 1, arg.LocationF.Y * -2 + 1, 0);
// // invert the matrix.
// trans = Matrix4.Invert(trans);
// // trans now converts from the world coord system (at the camera) to
// // the local coord system in the 'target' group node (surface).
// // In order to transform the mouse (viewport) position, we
// // left multiply the transformation matrix.
// pos = trans * pos;
// // view result in the window title
// //Text = "Model Position: " + pos.ToString();
// ThreadSafeOperations.SetText(lblStatus, pos.ToString(), false);
// }
// }
//};
ilPanel1.Scene = scene;
}
private void btnProcess_Click(object sender, EventArgs e)
{
string fName = richTextBox1.Text;
if (!File.Exists(fName))
{
theLogWindow = ServiceTools.LogAText(theLogWindow, "couldn`t find a file: " + fName);
return;
}
try
{
xlApp = new Microsoft.Office.Interop.Excel.Application();
xlApp.Visible = true;
wb = xlApp.Workbooks.Open(fName, Type.Missing, false);
ws = wb.Sheets[1];
}
catch (Exception)
{
CloseAll();
}
List <Tuple <int, SunElevationTestDataRecord> > lRecords = new List <Tuple <int, SunElevationTestDataRecord> >();
int rowIdx = 2;
double dDataTimeRead = 0.0d;
while (true)
{
DateTime dtVal;
SunElevationTestDataRecord currRec = new SunElevationTestDataRecord();
System.Windows.Forms.Application.DoEvents();
try
{
Range rngDT = ws.Cells[rowIdx, 1];
var dDataTimeReadValue = rngDT.Value2;
if (dDataTimeReadValue == null)
{
theLogWindow = ServiceTools.LogAText(theLogWindow,
"date-time value at row " + rowIdx + " is empty. Stopping reading.");
CloseAll();
break;
}
dDataTimeRead = (double)(dDataTimeReadValue);
if (dDataTimeRead == 0.0d)
{
theLogWindow = ServiceTools.LogAText(theLogWindow,
"date-time value at row " + rowIdx + " is empty. Stopping reading.");
CloseAll();
break;
}
}
catch (Exception ex)
{
//CloseAll();
theLogWindow = ServiceTools.LogAText(theLogWindow, "=====================");
theLogWindow = ServiceTools.LogAText(theLogWindow,
ex.Message + Environment.NewLine + "for date-time value at row " + rowIdx);
theLogWindow = ServiceTools.LogAText(theLogWindow, "=====================");
lRecords.Add(new Tuple <int, SunElevationTestDataRecord>(rowIdx, currRec));
rowIdx++;
continue;
}
dtVal = DateTime.FromOADate(dDataTimeRead);
currRec.Dt = dtVal;
double latVal = 0.0d;
try
{
Range rngLat = ws.Cells[rowIdx, 2];
var rngLatVal = rngLat.Value2;
if (rngLatVal == null)
{
theLogWindow = ServiceTools.LogAText(theLogWindow,
"latitude value at row " + rowIdx + " is empty");
//rowIdx++;
//continue;
}
else
{
latVal = (double)(rngLatVal);
currRec.latDec = latVal;
}
}
catch (Exception ex)
{
//CloseAll();
theLogWindow = ServiceTools.LogAText(theLogWindow, "=====================");
theLogWindow = ServiceTools.LogAText(theLogWindow,
ex.Message + Environment.NewLine + "for latitude value at row " + rowIdx);
theLogWindow = ServiceTools.LogAText(theLogWindow, "=====================");
lRecords.Add(new Tuple <int, SunElevationTestDataRecord>(rowIdx, currRec));
rowIdx++;
continue;
}
double lonVal = 0.0d;
try
{
Range rngLon = ws.Cells[rowIdx, 3];
var rngLonVal = rngLon.Value2;
if (rngLonVal == null)
{
theLogWindow = ServiceTools.LogAText(theLogWindow,
"longitude value at row " + rowIdx + " is empty");
//rowIdx++;
//continue;
}
else
{
lonVal = (double)(rngLonVal);
currRec.lonDec = lonVal;
}
}
catch (Exception ex)
{
//CloseAll();
theLogWindow = ServiceTools.LogAText(theLogWindow, "=====================");
theLogWindow = ServiceTools.LogAText(theLogWindow,
ex.Message + Environment.NewLine + "for longitude value at row " + rowIdx);
theLogWindow = ServiceTools.LogAText(theLogWindow, "=====================");
lRecords.Add(new Tuple <int, SunElevationTestDataRecord>(rowIdx, currRec));
rowIdx++;
continue;
}
double sunAltTestVal = 0.0d;
try
{
Range rngSunAltTest = ws.Cells[rowIdx, 4];
var rngSunAltTestVal = rngSunAltTest.Value2;
if (rngSunAltTestVal == null)
{
theLogWindow = ServiceTools.LogAText(theLogWindow,
"testing sun elevation value at row " + rowIdx + " is empty");
//rowIdx++;
//continue;
}
else
{
sunAltTestVal = (double)(rngSunAltTestVal);
currRec.SunElevTest = sunAltTestVal;
}
}
catch (Exception ex)
{
theLogWindow = ServiceTools.LogAText(theLogWindow, "=====================");
theLogWindow = ServiceTools.LogAText(theLogWindow,
ex.Message + Environment.NewLine + "for read sun elevation value at row " + rowIdx);
theLogWindow = ServiceTools.LogAText(theLogWindow, "=====================");
//CloseAll();
lRecords.Add(new Tuple <int, SunElevationTestDataRecord>(rowIdx, currRec));
rowIdx++;
continue;
}
ThreadSafeOperations.SetText(lblLoadingStatus, "loading " + rowIdx + " row", false);
lRecords.Add(new Tuple <int, SunElevationTestDataRecord>(rowIdx, currRec));
rowIdx++;
}
List <double> lDeviations = new List <double>();
string outFName = Path.GetDirectoryName(fName) + "\\" + Path.GetFileNameWithoutExtension(fName) + "-output.txt";
ServiceTools.logToTextFile(outFName, SunElevationTestDataRecord.TableFieldsHeader() + Environment.NewLine, true);
foreach (Tuple <int, SunElevationTestDataRecord> tpl in lRecords)
{
rowIdx = tpl.Item1;
SunElevationTestDataRecord currRec = tpl.Item2;
if (currRec.WhetherAllValuesHasBeenRead)
{
SPA spaCalc = new SPA(currRec.Dt.Year, currRec.Dt.Month, currRec.Dt.Day, currRec.Dt.Hour,
currRec.Dt.Minute, currRec.Dt.Second, (float)currRec.lonDec, (float)currRec.latDec,
(float)SPAConst.DeltaT(currRec.Dt));
int res = spaCalc.spa_calculate();
AzimuthZenithAngle sunPositionSPAext = new AzimuthZenithAngle(spaCalc.spa.azimuth,
spaCalc.spa.zenith);
currRec.SunElevCalc = sunPositionSPAext.ElevationAngle;
lDeviations.Add(currRec.SunElevCalc - currRec.SunElevTest);
ServiceTools.logToTextFile(outFName, currRec.ToString() + Environment.NewLine, true);
}
else
{
ServiceTools.logToTextFile(outFName, currRec.ToString() + Environment.NewLine, true);
}
}
HistogramDataAndProperties histData = new HistogramDataAndProperties(DenseVector.OfEnumerable(lDeviations), 20);
HistogramCalcAndShowForm histForm = new HistogramCalcAndShowForm("", defaultProperties);
histForm.HistToRepresent = histData;
histForm.Show();
histForm.Represent();
CloseAll();
}
//private void cbShowGeoTrack_CheckedChanged(object sender, EventArgs e)
//{
// if (((sender as CheckBox).Checked) && (!bgwGeotrackRenderer.IsBusy) && (!bgwStreamDataProcessing.IsBusy))
// {
// var repl = MessageBox.Show("Wanna watch right now?", "Right now?", MessageBoxButtons.YesNoCancel,
// MessageBoxIcon.Question, MessageBoxDefaultButton.Button3);
// if (repl == System.Windows.Forms.DialogResult.Yes)
// {
// DoWorkEventHandler bgw1DoWorkHandler = delegate(object currBGWsender, DoWorkEventArgs args)
// {
// ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, true, true, wcUpdatimgGeoTrack.Color);
// BackgroundWorker selfWorker = currBGWsender as BackgroundWorker;
// object[] currBGWarguments = (object[])args.Argument;
// ShowGeoTrackOnce();
// args.Result = new object[] { "" };
// };
// RunWorkerCompletedEventHandler currWorkCompletedHandler = delegate(object currBGWCompletedSender, RunWorkerCompletedEventArgs args)
// {
// object[] currentBGWResults = (object[])args.Result;
// ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, false, false, wcUpdatimgGeoTrack.Color);
// };
// BackgroundWorker bgw1 = new BackgroundWorker();
// bgw1.DoWork += bgw1DoWorkHandler;
// bgw1.RunWorkerCompleted += currWorkCompletedHandler;
// object[] BGWargs = new object[] { "" };
// bgw1.RunWorkerAsync(BGWargs);
// }
// }
// else if ((!(sender as CheckBox).Checked) && (bgwGeotrackRenderer.IsBusy))
// {
// bgwGeotrackRenderer.CancelAsync();
// }
// else if (((sender as CheckBox).Checked) && (!bgwGeotrackRenderer.IsBusy) && (bgwStreamDataProcessing.IsBusy))
// {
// bgwGeotrackRenderer.RunWorkerAsync();
// }
//}
//private void scrbGeoTrackScrollLonValues_ValueChanged(object sender, EventArgs e)
//{
// if (scrbGeoTrackScrollLonValues.Value == 0)
// {
// return;
// }
// if (showGeoTrack)
// {
// while (!Monitor.TryEnter(geoRenderer, 100))
// {
// Application.DoEvents();
// Thread.Sleep(0);
// }
// try
// {
// geoRenderer.MoveGPSWindow(-scrbGeoTrackScrollLonValues.Value, 0);
// }
// finally
// {
// Monitor.Exit(geoRenderer);
// }
// scrbGeoTrackScrollLonValues.Value = 0;
// BackgroundWorker bgwGraphUpdater = new BackgroundWorker();
// DoWorkEventHandler bgwGraphUpdaterDoWorkHandler = delegate (object currBGWsender, DoWorkEventArgs args)
// {
// BackgroundWorker selfWorker = currBGWsender as BackgroundWorker;
// object[] currBGWarguments = (object[])args.Argument;
// Stopwatch sw1 = Stopwatch.StartNew();
// bool retResult = false;
// while (true)
// {
// ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, true, true, wcUpdatimgGeoTrack.Color);
// if (UpdateGeoTrack())
// {
// retResult = true;
// break;
// }
// else if (sw1.ElapsedMilliseconds > 10000)
// {
// retResult = false;
// break;
// }
// ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, false, false, wcUpdatimgGeoTrack.Color);
// Application.DoEvents();
// Thread.Sleep(0);
// }
// args.Result = new object[] { retResult };
// };
// RunWorkerCompletedEventHandler bgwGraphUpdaterCompletedHandler = delegate (object currBGWCompletedSender, RunWorkerCompletedEventArgs args)
// {
// object[] currentBGWResults = (object[])args.Result;
// bool UpdatingResult = (bool)(currentBGWResults[0]);
// if (!UpdatingResult)
// {
// ThreadSafeOperations.SetText(lblStatusString, DateTime.Now.ToString("s").Replace("T", " ") + ": Geogtrack failed to be updated.", false);
// }
// ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, false, false, wcUpdatimgGeoTrack.Color);
// };
// bgwGraphUpdater.DoWork += bgwGraphUpdaterDoWorkHandler;
// bgwGraphUpdater.RunWorkerCompleted += bgwGraphUpdaterCompletedHandler;
// bgwGraphUpdater.RunWorkerAsync();
// //}
// }
//}
//private void scrbGeoTrackScrollLatValues_ValueChanged(object sender, EventArgs e)
//{
// if (scrbGeoTrackScrollLatValues.Value == 0)
// {
// return;
// }
// if (showGeoTrack)
// {
// while (!Monitor.TryEnter(geoRenderer, 100))
// {
// Application.DoEvents();
// Thread.Sleep(0);
// }
// try
// {
// geoRenderer.MoveGPSWindow(0, -scrbGeoTrackScrollLatValues.Value);
// }
// finally
// {
// Monitor.Exit(geoRenderer);
// }
// scrbGeoTrackScrollLatValues.Value = 0;
// //if (bgwGraphsRenderer.IsBusy)
// //{
// // needToUpdateGeoTrackNow = true;
// //}
// //else
// //{
// BackgroundWorker bgwGraphUpdater = new BackgroundWorker();
// DoWorkEventHandler bgwGraphUpdaterDoWorkHandler = delegate(object currBGWsender, DoWorkEventArgs args)
// {
// BackgroundWorker selfWorker = currBGWsender as BackgroundWorker;
// object[] currBGWarguments = (object[])args.Argument;
// Stopwatch sw1 = Stopwatch.StartNew();
// bool retResult = false;
// while (true)
// {
// ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, true, true, wcUpdatimgGeoTrack.Color);
// if (UpdateGeoTrack())
// {
// retResult = true;
// break;
// }
// else if (sw1.ElapsedMilliseconds > 10000)
// {
// retResult = false;
// break;
// }
// ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, false, false, wcUpdatimgGeoTrack.Color);
// Application.DoEvents();
// Thread.Sleep(0);
// }
// args.Result = new object[] { retResult };
// };
// RunWorkerCompletedEventHandler bgwGraphUpdaterCompletedHandler = delegate(object currBGWCompletedSender, RunWorkerCompletedEventArgs args)
// {
// object[] currentBGWResults = (object[])args.Result;
// bool UpdatingResult = (bool)(currentBGWResults[0]);
// if (!UpdatingResult)
// {
// ThreadSafeOperations.SetText(lblStatusString, DateTime.Now.ToString("s").Replace("T", " ") + ": Geogtrack failed to be updated.", false);
// }
// ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, false, false, wcUpdatimgGeoTrack.Color);
// };
// bgwGraphUpdater.DoWork += bgwGraphUpdaterDoWorkHandler;
// bgwGraphUpdater.RunWorkerCompleted += bgwGraphUpdaterCompletedHandler;
// bgwGraphUpdater.RunWorkerAsync();
// //}
// }
//}
#endregion // obsolete
private void btnCenterToActualPosition_Click(object sender, EventArgs e)
{
//if (showGeoTrack)
//{
while (!Monitor.TryEnter(geoRenderer, 100))
{
Application.DoEvents();
Thread.Sleep(0);
}
try
{
//geoRenderer.MoveGPSWindow(actualGPSdata);
geoRenderer.mapFollowsActualGPSposition = true;
}
finally
{
Monitor.Exit(geoRenderer);
}
//if (bgwGraphsRenderer.IsBusy)
//{
// needToUpdateGeoTrackNow = true;
//}
//else
//{
BackgroundWorker bgwGraphUpdater = new BackgroundWorker();
DoWorkEventHandler bgwGraphUpdaterDoWorkHandler = delegate(object currBGWsender, DoWorkEventArgs args)
{
BackgroundWorker selfWorker = currBGWsender as BackgroundWorker;
object[] currBGWarguments = (object[])args.Argument;
Stopwatch sw1 = Stopwatch.StartNew();
bool retResult = false;
while (true)
{
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, true, true, wcUpdatimgGeoTrack.Color);
if (UpdateGeoTrack())
{
retResult = true;
break;
}
else if (sw1.ElapsedMilliseconds > 10000)
{
retResult = false;
break;
}
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, false, false, wcUpdatimgGeoTrack.Color);
Application.DoEvents();
Thread.Sleep(0);
}
args.Result = new object[] { retResult };
};
RunWorkerCompletedEventHandler bgwGraphUpdaterCompletedHandler = delegate(object currBGWCompletedSender, RunWorkerCompletedEventArgs args)
{
object[] currentBGWResults = (object[])args.Result;
bool UpdatingResult = (bool)(currentBGWResults[0]);
if (!UpdatingResult)
{
ThreadSafeOperations.SetText(lblStatusString, DateTime.Now.ToString("s").Replace("T", " ") + ": Geogtrack failed to be updated.", false);
}
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, false, false, wcUpdatimgGeoTrack.Color);
};
bgwGraphUpdater.DoWork += bgwGraphUpdaterDoWorkHandler;
bgwGraphUpdater.RunWorkerCompleted += bgwGraphUpdaterCompletedHandler;
bgwGraphUpdater.RunWorkerAsync();
//}
//}
}
private void btnPerformExport_Click(object sender, EventArgs e)
{
string outPath = rtbExportDestinationDirectoryPath.Text;
outPath += (outPath.Last() == '\\') ? ("") : ("\\");
if (cbExportMeteoData.Checked)
{
//export meteo data
BackgroundWorker bgwReadMeteoData = new BackgroundWorker();
bgwReadMeteoData.WorkerSupportsCancellation = false;
bgwReadMeteoData.WorkerReportsProgress = true;
bgwReadMeteoData.DoWork += delegate(object currBGWsender, DoWorkEventArgs args)
{
BackgroundWorker selfWorker = currBGWsender as BackgroundWorker;
TimeSeries <MeteoData> tsMeteoData = new TimeSeries <MeteoData>();
string[] meteoDataFiles = Directory.GetFiles(Directory.GetCurrentDirectory() + "\\logs\\",
"*MeteoDataLog*.nc");
int totalFilesCount = meteoDataFiles.Count();
int readFiles = 0;
foreach (string meteoDataFileName in meteoDataFiles)
{
ThreadSafeOperations.SetText(lblStatusBar, "reading " + Path.GetFileName(meteoDataFileName), false);
Dictionary <string, object> currMeteoFileData =
NetCDFoperations.ReadDataFromFile(meteoDataFileName);
List <MeteoData> currFileMeteoData =
MeteoData.OfDenseMatrix(currMeteoFileData["MeteoData"] as DenseMatrix);
List <long> currFileDatetimeLong = new List <long>(currMeteoFileData["DateTime"] as long[]);
List <DateTime> currFileDatetime =
currFileDatetimeLong.ConvertAll <DateTime>(longDT => new DateTime(longDT));
tsMeteoData.AddSubseriaData(currFileMeteoData, currFileDatetime, true);
readFiles++;
selfWorker.ReportProgress(Convert.ToInt32(100.0d * readFiles / totalFilesCount));
}
args.Result = new object[] { tsMeteoData };
};
bgwReadMeteoData.ProgressChanged += delegate(object currBGWsender, ProgressChangedEventArgs args)
{
ThreadSafeOperations.UpdateProgressBar(prbExportProgress, args.ProgressPercentage);
};
bgwReadMeteoData.RunWorkerCompleted += delegate(object currBGWsender, RunWorkerCompletedEventArgs args)
{
ThreadSafeOperations.UpdateProgressBar(prbExportProgress, 0);
TimeSeries <MeteoData> tsMeteoData = (args.Result as object[])[0] as TimeSeries <MeteoData>;
List <Tuple <DateTime, MeteoData> > lTplMeteoData =
tsMeteoData.TimeStamps.Zip(tsMeteoData.DataValues,
(dt, dat) => new Tuple <DateTime, MeteoData>(dt, dat)).ToList();
if (cbExportFormatCSV.Checked)
{
List <string> tsMeteoDataCSV = lTplMeteoData.ConvertAll <string>(tpl => tpl.Item1.ToString("o") + "," + tpl.Item2.ToCSV());
string tsMeteoDataCSVForFile = String.Join(Environment.NewLine, tsMeteoDataCSV.ToArray <string>());
ServiceTools.logToTextFile(outPath + "MeteoData.csv", "DateTime," + lTplMeteoData[0].Item2.CSVHeader() + Environment.NewLine, false, false);
ServiceTools.logToTextFile(outPath + "MeteoData.csv", tsMeteoDataCSVForFile, true, false);
}
};
ThreadSafeOperations.SetText(lblStatusBar, "meteo data read started", false);
bgwReadMeteoData.RunWorkerAsync();
}
}
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);
}