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 static bool geoTrackIsUpdatingNow = false;
private bool UpdateGeoTrack()
{
while (!Monitor.TryEnter(geoRenderer, 100))
{
Application.DoEvents();
Thread.Sleep(100);
}
try
{
geoRenderer.listMarkers.Clear();
geoRenderer.listMarkers.Add(new Tuple <GPSdata, SequencesDrawingVariants, Bgr>(actualGPSdata,
SequencesDrawingVariants.triangles, GeoTrackRenderer.tracksColor));
if (geoRenderer.mapFollowsActualGPSposition)
{
geoRenderer.gpsMapCenteredPoint = actualGPSdata.Clone();
}
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, true, true, wcUpdatimgGeoTrack.Color);
//ThreadSafeOperations.UpdateImagePanel(imgPanelGeotrack, geoRenderer.RepresentTopo(imgPanelGeotrack.Size), cbNormalizeImage.Checked);
//ThreadSafeOperations.UpdateImagePanel(imgPanelGeotrack, geoRenderer.RepresentTopo(new Size(0, 0)), cbNormalizeImage.Checked);
ThreadSafeOperations.UpdatePictureBox(pbGeotrack, geoRenderer.RepresentTopo(new Size(0, 0)), cbNormalizeImage.Checked);
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, false, false, wcUpdatimgGeoTrack.Color);
}
finally
{
Monitor.Exit(geoRenderer);
}
return(true);
}
private void LoadFieldData()
{
//if (tbFileName.Text != "")
//{
// if (File.Exists(tbFileName.Text))
// {
// currFileName = tbFileName.Text;
// }
//}
//else
//{
// OpenFileDialog d1 = new OpenFileDialog();
// d1.DefaultExt = "NetCDF files *.nc | *.nc";
// DialogResult res = d1.ShowDialog();
// if (res == System.Windows.Forms.DialogResult.Cancel) return;
// if (res == System.Windows.Forms.DialogResult.OK)
// {
// ThreadSafeOperations.SetTextTB(tbFileName, d1.FileName, false);
// currFileName = d1.FileName;
// }
//}
//
//dmLoadedData = NetCDFoperations.ReadDenseMatrixFromFile(currFileName, fieldVarName);
currImgData = new imageConditionAndData(dmLoadedData, null);
currImgData.currentColorSchemeRuler = new ColorSchemeRuler(currImgData.currentColorScheme);
currImgData.UpdateColorSchemeRuler();
currImgData.currentColorSchemeRuler.IsMarginsFixed = false;
currImgData.UpdateColorSchemeRuler();
currImage = new Image <Bgr, byte>(currImgData.dataRepresentingImageColored());
ThreadSafeOperations.UpdatePictureBox(pbCurrResult, currImage.Bitmap, true);
sectionsList = new List <SectionDescription>();
currSectionPoints = new Tuple <PointD, PointD>(PointD.nullPointD(), PointD.nullPointD());
}
private void buttonSelect_Click(object sender, EventArgs e)
{
RichTextBox currFilenameTextbox = rtbFromPath;
if (sender == btnFromPathSelect)
{
currFilenameTextbox = rtbFromPath;
}
else if (sender == btnToPathSelect)
{
currFilenameTextbox = rtbToPath;
}
else if (sender == btnConcurrentDataPathSelect)
{
currFilenameTextbox = rtbConcurrentDataDir;
}
else if (sender == btnStatsDirPathSelect)
{
currFilenameTextbox = rtbGrIxYRGBstatsDir;
}
FolderBrowserDialog opFD = new FolderBrowserDialog();
opFD.ShowNewFolderButton = true;
opFD.SelectedPath = Directory.GetCurrentDirectory();
DialogResult dialogRes = opFD.ShowDialog();
if (dialogRes == DialogResult.OK)
{
String pathName = opFD.SelectedPath;
//FileInfo fInfo = new FileInfo(filename);
ThreadSafeOperations.SetTextTB(currFilenameTextbox, pathName, false);
}
}
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 ExternalGraphImageFormResized(object sender, EventArgs e)
{
BackgroundWorker bgwGenerateGraphImage = new BackgroundWorker();
SimpleShowImageForm f1 = sender as SimpleShowImageForm;
bgwGenerateGraphImage.DoWork += (sndr, args) =>
{
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGraph, true, true, wcUpdatimgGraph.Color);
Image <Bgr, byte> img = FillGraphImage(f1.pb1.Size);
args.Result = new object[] { img };
};
bgwGenerateGraphImage.RunWorkerCompleted += (sndr, args) =>
{
Image <Bgr, byte> resImg = (args.Result as object[])[0] as Image <Bgr, byte>;
ServiceTools.ExecMethodInSeparateThread(this, delegate()
{
f1.UpdateBitmap(resImg.Bitmap);
});
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGraph, false, false, wcUpdatimgGraph.Color);
};
bgwGenerateGraphImage.RunWorkerAsync();
}
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);
}
void bgwGraphsPresenter_DoWork(object sender, DoWorkEventArgs e)
{
Thread.CurrentThread.Priority = ThreadPriority.Lowest;
graphImage = FillGraphImage(pbGraphs.Size);
if (graphImage != null)
{
ThreadSafeOperations.UpdatePictureBox(pbGraphs, graphImage, false);
}
}
private void RenderAndShowGraph(object state)
{
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGraph, true, true, wcUpdatimgGraph.Color);
bgwGraphsPresenter = new BackgroundWorker();
bgwGraphsPresenter.DoWork += bgwGraphsPresenter_DoWork;
bgwGraphsPresenter.RunWorkerCompleted += bgwGraphsPresenter_RunWorkerCompleted;
bgwGraphsPresenter.RunWorkerAsync();
}
private void SendCommandDev2()
{
currCommand = textBoxCommand2.Text.Trim().Replace("\0", string.Empty);
if (currCommand.Length == 0)
{
return;
}
ThreadSafeOperations.SetTextTB(textBoxCommand2, "", false);
ThreadSafeOperations.SetTextTB(tbResponseLog2, ">>> " + currCommand + Environment.NewLine, true);
PerformSendCommand(2);
}
private void btnCancelWaitingResponse_Click(object sender, EventArgs e)
{
currCommand = textBoxCommand1.Text.Trim().Replace("\0", string.Empty);
if (currCommand.Length == 0)
{
return;
}
ThreadSafeOperations.SetTextTB(textBoxCommand1, "", false);
ThreadSafeOperations.SetTextTB(tbResponseLog1, ">>> " + currCommand + Environment.NewLine, true);
PerformSendCommand();
}
private void btnUpdate_Click(object sender, EventArgs e)
{
//showGeoTrack = !showGeoTrack;
//if (showGeoTrack)
//{
// ThreadSafeOperations.ToggleButtonState(btnUpdate, true, "ON", true);
//}
//else
//{
// ThreadSafeOperations.ToggleButtonState(btnUpdate, true, "OFF", true);
//}
//if (showGeoTrack && !bgwGeotrackRenderer.IsBusy && !bgwStreamDataProcessing.IsBusy)
if (!bgwGeotrackRenderer.IsBusy)
{
//var repl = MessageBox.Show("Wanna watch right now?", "Right now?", MessageBoxButtons.YesNoCancel,
// MessageBoxIcon.Question, MessageBoxDefaultButton.Button3);
//if (repl == DialogResult.Yes)
//{
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, true, true, wcUpdatimgGeoTrack.Color);
DoWorkEventHandler bgw1DoWorkHandler = delegate(object currBGWsender, DoWorkEventArgs args)
{
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 (!showGeoTrack && bgwGeotrackRenderer.IsBusy)
//{
// bgwGeotrackRenderer.CancelAsync();
//}
//else if ((showGeoTrack) && (!bgwGeotrackRenderer.IsBusy) && (bgwStreamDataProcessing.IsBusy))
//{
// bgwGeotrackRenderer.RunWorkerAsync();
//}
}
private void ShowGeoTrackOnce()
{
// пропишем в рисователь трека имена файлов, содержащих логи данных GPS
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, true, true, wcUpdatimgGeoTrack.Color);
while (!Monitor.TryEnter(geoRenderer, 100))
{
Application.DoEvents();
Thread.Sleep(0);
}
try
{
if ((geoRenderer.lTracksData.Count == 0) || (geoRenderer.lTracksData[0].tsGPSdata.Count == 0))
{
DirectoryInfo dirInfo = new DirectoryInfo(Directory.GetCurrentDirectory() + "\\logs\\");
foreach (FileInfo fInfo in dirInfo.EnumerateFiles("*GPS*.nc", SearchOption.TopDirectoryOnly))
{
geoRenderer.listGPSdataLogNetCDFFileNames.Add(fInfo.FullName);
}
geoRenderer.ReadGPSFiles(lblStatusString);
}
if ((geoRenderer.lTracksData[0].tsGPSdata.Count > 0))
{
actualGPSdata = geoRenderer.lTracksData[0].tsGPSdata.DataValues.Last();
}
else
{
actualGPSdata = new GPSdata(6000.0d, 0.0d);
}
geoRenderer.listMarkers.Clear();
geoRenderer.listMarkers.Add(new Tuple <GPSdata, SequencesDrawingVariants, Bgr>(actualGPSdata,
SequencesDrawingVariants.triangles, GeoTrackRenderer.tracksColor));
if (geoRenderer.mapFollowsActualGPSposition)
{
geoRenderer.gpsMapCenteredPoint = actualGPSdata.Clone();
}
// ThreadSafeOperations.UpdateImagePanel(imgPanelGeotrack, geoRenderer.RepresentTopo(imgPanelGeotrack.Size), cbNormalizeImage.Checked);
//ThreadSafeOperations.UpdateImagePanel(imgPanelGeotrack, geoRenderer.RepresentTopo(new Size(0, 0)), cbNormalizeImage.Checked);
//ThreadSafeOperations.UpdatePictureBox(pbGeotrack, geoRenderer.RepresentTopo(new Size(0, 0)), cbNormalizeImage.Checked);
ThreadSafeOperations.UpdatePictureBox(pbGeotrack, geoRenderer.RepresentTopo(pbGeotrack.Size), cbNormalizeImage.Checked);
}
finally
{
Monitor.Exit(geoRenderer);
}
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGeoTrack, false, false, wcUpdatimgGeoTrack.Color);
}
//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 MainForm_Paint(object sender, PaintEventArgs e)
{
if (currImage != null)
{
Image <Bgr, byte> currShowingImage = currImage.Copy();
foreach (SectionDescription sectionDescription in sectionsList)
{
currShowingImage.Draw(
new LineSegment2DF(sectionDescription.p1.PointF(), sectionDescription.p2.PointF()),
new Bgr(Color.Black), 2);
}
ThreadSafeOperations.UpdatePictureBox(pbCurrResult, currShowingImage.Bitmap, true);
}
}
public void Note(string text, TextBox tb2update)
{
ThreadSafeOperations.SetTextTB(tb2update, text + Environment.NewLine, true);
if ((tb2update == tbBcstListeningLog) && (tb2update.Lines.Length > Settings.Default.BroadcastLogHistorySizeLines))
{
swapBcstLog();
Note(text, tb2update);
}
if ((tb2update == tbResponseLog1) && (tb2update.Lines.Length > Settings.Default.BroadcastLogHistorySizeLines))
{
swapResponseLog(btnSwapResponseLog1);
Note(text, tb2update);
}
}
private void btnSelectVesselNavDataDirectory_Click(object sender, EventArgs e)
{
RichTextBox currFilenameTextbox = rtbVesselNavDataDirectoryPath;
FolderBrowserDialog opFD = new FolderBrowserDialog();
opFD.ShowNewFolderButton = true;
opFD.SelectedPath = Directory.GetCurrentDirectory();
DialogResult dialogRes = opFD.ShowDialog();
if (dialogRes == DialogResult.OK)
{
String pathName = opFD.SelectedPath;
ThreadSafeOperations.SetTextTB(currFilenameTextbox, pathName, false);
}
}
private void swapBcstLog()
{
string filename1;
string strtowrite;
byte[] info2write;
filename1 = Directory.GetCurrentDirectory() + "\\BcstLog-" + DateTime.Now.Year + "-" + DateTime.Now.Month + "-" + DateTime.Now.Day + "-" + DateTime.Now.Hour + "-" + DateTime.Now.Minute + "-" + DateTime.Now.Second + ".log";
FileStream dataFile = new FileStream(filename1, FileMode.Append, FileAccess.Write);
strtowrite = tbBcstListeningLog.Text;
info2write = new UTF8Encoding(true).GetBytes(strtowrite);
dataFile.Write(info2write, 0, info2write.Length);
dataFile.Close();
ThreadSafeOperations.SetTextTB(tbBcstListeningLog, "", false);
}
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 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);
}
}
void bgwGraphsPresenterInSeparateWindow_DoWork(object sender, DoWorkEventArgs e)
{
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGraph, true, true, wcUpdatimgGraph.Color);
Image <Bgr, byte> img = FillGraphImage(new Size(1280, 1024));
if (img != null)
{
ServiceTools.ExecMethodInSeparateThread(this, delegate()
{
SimpleShowImageForm f1 = new SimpleShowImageForm(img.Bitmap);
f1.FormResizing += ExternalGraphImageFormResized;
f1.Show();
});
}
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGraph, false, false, wcUpdatimgGraph.Color);
}
private void btnOpenAnotherLogFile_Click(object sender, EventArgs e)
{
OpenFileDialog fileOpen = new OpenFileDialog();
if (fileOpen.ShowDialog() == DialogResult.OK)
{
strLogFilename = fileOpen.FileName;
Dictionary <string, object> dictDataToShow = NetCDFoperations.ReadDataFromFile(strLogFilename);
if (!dictDataToShow.Keys.Contains("AccelerometerData"))
{
MessageBox.Show("It`s not an acceleration data log. Try another file.", "", MessageBoxButtons.OK,
MessageBoxIcon.Warning);
}
sensorsHistoryRepresentingScale = 30;
ThreadSafeOperations.MoveTrackBar(trackBar1, 30);
strLogFilename = fileOpen.FileName;
Represent();
}
}
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 bool testAnIpAddress(IPAddress testingIPaddr)
//{
// bool retVal = false;
// Ping ping;
// string retStr = "areyouarduino";
// byte[] ret = System.Text.Encoding.ASCII.GetBytes(retStr);
// string returnData = "";
// Socket Skt = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
// Skt.EnableBroadcast = false;
// Skt.ReceiveTimeout = 10;
// Skt.SendTimeout = 10;
// //string testingIP = "192.168.192." + i.ToString();//!!!!!!!!!!!!!!!!!!!!!! определить подсеть по текущему IP и маске
// //testingIPaddr = IPAddress.Parse(testingIP);
//
// ping = new Ping();
// PingReply repl = ping.Send(testingIPaddr, 3, new byte[] { 1 }, new PingOptions(1, true));
//
// if ((repl.Status == IPStatus.TtlExpired) || (repl.Status == IPStatus.TimedOut) || (repl.Status == IPStatus.TimeExceeded))
// {
// returnData = "ping timeout or not reachable";
// retVal = false;
// }
// else
// {
// IPEndPoint test = new IPEndPoint(testingIPaddr, 5555);
// int sent = Skt.SendTo(ret, test);
// // Blocks until a message returns on this socket from a remote host.
// Byte[] receiveBytes = new byte[128];
// IPEndPoint sender_ = new IPEndPoint(IPAddress.Any, 0);
// EndPoint senderRemote = (EndPoint)sender_;
//
// try
// {
// Skt.ReceiveFrom(receiveBytes, ref senderRemote);
// returnData = Encoding.UTF8.GetString(receiveBytes).Trim().Replace("\0", string.Empty);
// }
// catch (Exception ex)
// {
// returnData = ex.Message;
// //throw;
// }
// }
//
// SetTextTB(textBox1, "tested ip " + testingIPaddr.ToString() + ": " + returnData.ToString() + Environment.NewLine, true);
// Skt.Close();
// if (returnData.ToString() == "YES") retVal = true; else retVal = false;
//
// return retVal;
//}
//private void arduinoBoardSearchingWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
//{
// //SetTextTB(textBox1, "Данные датчиков собраны " + e.ProgressPercentage + " раз" + Environment.NewLine, true);
// UpdateProgressBar(progressBar1, e.ProgressPercentage);
//}
private void Form1_Load(object sender, EventArgs e)
{
string generalSettingsFilename = Directory.GetCurrentDirectory() + "\\settings\\ArduinoUDPconversationAppGeneralSettings2G.xml";
if (!File.Exists(generalSettingsFilename))
{
ip2ListenDevID1 = Settings.Default.ArduinoBoardDefaultIP;
port2converse = Settings.Default.ArduinoBoardDefaultUDPport;
ThreadSafeOperations.SetTextTB(tbDev1IPstr, ip2ListenDevID1, false);
}
else
{
Dictionary <string, object> generalSettings = ServiceTools.ReadDictionaryFromXML(generalSettingsFilename);
ip2ListenDevID1 = generalSettings["ArduinoBoardID1DefaultIP"] as string;
ip2ListenDevID2 = generalSettings["ArduinoBoardID2DefaultIP"] as string;
port2converse = Convert.ToInt32(generalSettings["ArduinoBoardDefaultUDPport"]);
portBcstRecvng = Convert.ToInt32(generalSettings["UDPBroadcastDefaultListeningPort"]);
ThreadSafeOperations.SetTextTB(tbDev1IPstr, ip2ListenDevID1, false);
ThreadSafeOperations.SetTextTB(tbDev2IPstr, ip2ListenDevID2, false);
}
}
private void swapResponseLog(object sender)
{
string filename1;
string strtowrite;
byte[] info2write;
int curDevID = 1;
if (sender == btnSwapResponseLog1)
{
curDevID = 1;
}
else if (sender == btnSwapResponseLog2)
{
curDevID = 2;
}
filename1 = Directory.GetCurrentDirectory() + "\\ResponseLog-" + "devID" + curDevID + "-" +
DateTime.Now.Year + "-" + DateTime.Now.Month + "-" + DateTime.Now.Day + "-" + DateTime.Now.Hour +
"-" + DateTime.Now.Minute + "-" + DateTime.Now.Second + ".log";
ServiceTools.logToTextFile(filename1, tbResponseLog1.Text, true);
ThreadSafeOperations.SetTextTB(tbResponseLog1, "", 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 Represent()
{
Dictionary <string, object> dictDataToShow = NetCDFoperations.ReadDataFromFile(strLogFilename);
long[] arrDateTimeTicksValues = new long[] { 0 };
if (dictDataToShow.Keys.Contains("DateTime"))
{
arrDateTimeTicksValues = (long[])(dictDataToShow["DateTime"]);
}
else if (dictDataToShow.Keys.Contains("Datetime"))
{
arrDateTimeTicksValues = (long[])(dictDataToShow["Datetime"]);
}
else
{
MessageBox.Show("Couldn`t acces the DateTime field of the file " + strLogFilename, "",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
DenseVector dvSecondsVector = DenseVector.Create(arrDateTimeTicksValues.Length, i =>
{
DateTime dateTime1 = new DateTime(arrDateTimeTicksValues[i]);
TimeSpan dt = dateTime1 - dateTime1.Date;
return(dt.TotalSeconds);
});
dmAccData = (DenseMatrix)dictDataToShow["AccelerometerData"];
if (sensorsHistoryRepresentingScale < 86400)
{
double lastDateTimeSecondsValue = dvSecondsVector[dvSecondsVector.Count - 1];
int searchingIndex = dvSecondsVector.Count - 1;
for (int idx = dvSecondsVector.Count - 1; idx >= 0; idx--)
{
if (lastDateTimeSecondsValue - dvSecondsVector[idx] >= sensorsHistoryRepresentingScale)
{
searchingIndex = idx;
break;
}
}
dvSecondsVector =
(DenseVector)dvSecondsVector.SubVector(searchingIndex, dvSecondsVector.Count - searchingIndex);
dmAccData =
(DenseMatrix)dmAccData.SubMatrix(searchingIndex, dvSecondsVector.Count, 0, dmAccData.ColumnCount);
}
#region filter input data noise
List <DenseVector> dmAccDataFiltered = new List <DenseVector>();
Dictionary <string, DenseVector> dictCurrColumnFilteredData = new Dictionary <string, DenseVector>();
for (int col = 0; col < dmAccData.ColumnCount; col++)
{
DenseVector dvVectToFilter = (DenseVector)dmAccData.Column(col);
dictCurrColumnFilteredData = DataAnalysis.SavGolFilter(dvVectToFilter, dvSecondsVector, 6, 6, 0, 6);
dmAccDataFiltered.Add(dictCurrColumnFilteredData["values"]);
//dmAccData.SetColumn(col, dictCurrColumnFilteredData["values"]);
//dvSecondsVector = dictCurrColumnFilteredData["time"];
}
dvSecondsVector = dictCurrColumnFilteredData["time"];
dmAccData = (DenseMatrix)DenseMatrix.OfColumns(dvSecondsVector.Count, dmAccData.ColumnCount, dmAccDataFiltered);
#endregion filter input data noise
// надо рассчитать углы отклонения отдельно - по сглаженным данным и по данным гироскопа
DenseVector dvDataToShowDevAngleValue = (DenseVector)dmAccData.Column(6);
if (cbFilterData.Checked)
{
List <double> ac = new List <double>();
}
if (accDeviationAngleRenderer == null)
{
accDeviationAngleRenderer = new MultipleScatterAndFunctionsRepresentation(pbRepresentingDevAngle.Size);
accDeviationAngleRenderer.dvScatterXSpace.Add(dvSecondsVector);
accDeviationAngleRenderer.dvScatterFuncValues.Add(dvDataToShowDevAngleValue);
accDeviationAngleRenderer.scatterLineColors.Add(new Bgr(Color.Blue));
accDeviationAngleRenderer.scatterDrawingVariants.Add(SequencesDrawingVariants.polyline);
}
else
{
if (accDeviationAngleRenderer.xSpaceMin != dvSecondsVector.Max() - sensorsHistoryRepresentingScale)
{
accDeviationAngleRenderer.xSpaceMin = dvSecondsVector.Max() - sensorsHistoryRepresentingScale;
accDeviationAngleRenderer.dvScatterXSpace.Clear();
accDeviationAngleRenderer.dvScatterFuncValues.Clear();
accDeviationAngleRenderer.scatterLineColors.Clear();
accDeviationAngleRenderer.scatterDrawingVariants.Clear();
accDeviationAngleRenderer.dvScatterXSpace.Add(dvSecondsVector);
accDeviationAngleRenderer.dvScatterFuncValues.Add(dvDataToShowDevAngleValue);
accDeviationAngleRenderer.scatterLineColors.Add(new Bgr(Color.Blue));
accDeviationAngleRenderer.scatterDrawingVariants.Add(SequencesDrawingVariants.polyline);
}
}
accDeviationAngleRenderer.xSpaceMin = dvSecondsVector.Max() - sensorsHistoryRepresentingScale;
accDeviationAngleRenderer.Represent();
ThreadSafeOperations.UpdatePictureBox(pbRepresentingDevAngle, accDeviationAngleRenderer.TheImage.Bitmap);
DenseVector dvDataToShowAccMagnitudeDev = DenseVector.Create(dmAccData.RowCount, i =>
{
AccelerometerData currAccData = new AccelerometerData(dmAccData[i, 0], dmAccData[i, 1], dmAccData[i, 2]);
AccelerometerData calibrationAccData = new AccelerometerData(dmAccData[i, 3], dmAccData[i, 4], dmAccData[i, 5]);
return(currAccData.AccMagnitude - calibrationAccData.AccMagnitude);
});
if (accDeviationMagnitudeRenderer == null)
{
accDeviationMagnitudeRenderer = new MultipleScatterAndFunctionsRepresentation(pbRepresentingDevMagnitude.Size);
accDeviationMagnitudeRenderer.dvScatterXSpace.Add(dvSecondsVector);
accDeviationMagnitudeRenderer.dvScatterFuncValues.Add(dvDataToShowAccMagnitudeDev);
accDeviationMagnitudeRenderer.scatterLineColors.Add(new Bgr(Color.Blue));
accDeviationMagnitudeRenderer.scatterDrawingVariants.Add(SequencesDrawingVariants.polyline);
}
else
{
if (accDeviationMagnitudeRenderer.xSpaceMin != dvSecondsVector.Max() - sensorsHistoryRepresentingScale)
{
accDeviationMagnitudeRenderer.xSpaceMin = dvSecondsVector.Max() - sensorsHistoryRepresentingScale;
accDeviationMagnitudeRenderer.dvScatterXSpace.Clear();
accDeviationMagnitudeRenderer.dvScatterFuncValues.Clear();
accDeviationMagnitudeRenderer.scatterLineColors.Clear();
accDeviationMagnitudeRenderer.scatterDrawingVariants.Clear();
accDeviationMagnitudeRenderer.dvScatterXSpace.Add(dvSecondsVector);
accDeviationMagnitudeRenderer.dvScatterFuncValues.Add(dvDataToShowAccMagnitudeDev);
accDeviationMagnitudeRenderer.scatterLineColors.Add(new Bgr(Color.Blue));
accDeviationMagnitudeRenderer.scatterDrawingVariants.Add(SequencesDrawingVariants.polyline);
}
}
accDeviationMagnitudeRenderer.xSpaceMin = dvSecondsVector.Max() - sensorsHistoryRepresentingScale;
accDeviationMagnitudeRenderer.Represent();
ThreadSafeOperations.UpdatePictureBox(pbRepresentingDevMagnitude, accDeviationMagnitudeRenderer.TheImage.Bitmap);
AccelerometerData accCalibratedData = new AccelerometerData(dmAccData[0, 3], dmAccData[0, 4],
dmAccData[0, 5]);
double phiAngle = Math.Asin(accCalibratedData.xyProjectionMagnitude() / accCalibratedData.AccMagnitude);
double tmpL = accCalibratedData.AccMagnitude * Math.Sin(phiAngle) * Math.Cos(phiAngle);
double tmpLz = tmpL * Math.Sin(phiAngle);
double tmpLx = tmpL * Math.Cos(phiAngle) *
Math.Sqrt(1 +
accCalibratedData.AccY * accCalibratedData.AccY /
(accCalibratedData.AccX * accCalibratedData.AccX));
double tmpLy = tmpLx * accCalibratedData.AccY / accCalibratedData.AccX;
AccelerometerData unitaryAccVectorZeroAngle = new AccelerometerData(tmpLx, tmpLy, tmpLz);
unitaryAccVectorZeroAngle = unitaryAccVectorZeroAngle / unitaryAccVectorZeroAngle.AccMagnitude;
AccelerometerData unitaryAccVectorCalibratedAcceleration = accCalibratedData / (accCalibratedData.AccMagnitude);
DenseVector dvDataToShowAccDevDirection = DenseVector.Create(dmAccData.RowCount, i =>
{
AccelerometerData currAccData = new AccelerometerData(dmAccData[i, 0], dmAccData[i, 1], dmAccData[i, 2]);
AccelerometerData currAccDataProjectionPerpendicularToCalibratedAcc = currAccData -
unitaryAccVectorCalibratedAcceleration *
(currAccData * accCalibratedData / accCalibratedData.AccMagnitude);
double retAngle =
Math.Acos(currAccDataProjectionPerpendicularToCalibratedAcc * unitaryAccVectorZeroAngle /
currAccDataProjectionPerpendicularToCalibratedAcc.AccMagnitude);
AccelerometerData vectProduct = unitaryAccVectorZeroAngle ^
currAccDataProjectionPerpendicularToCalibratedAcc;
if (vectProduct * unitaryAccVectorCalibratedAcceleration > 0)
{
//значит угол лежит в пределах от 0 до PI - ничего не делаем
retAngle = retAngle + 0.0d;
}
else
{
//векторное произведение противоположно по направлению g0 - значит, угол лежит в диапазоне от Pi до 2Pi или от -PI до PI
retAngle = -retAngle;
}
return(retAngle);
});
if (accDeviationDirectionRenderer == null)
{
accDeviationDirectionRenderer = new MultipleScatterAndFunctionsRepresentation(pbRepresentingDevDirection.Size);
accDeviationDirectionRenderer.dvScatterXSpace.Add(dvSecondsVector);
accDeviationDirectionRenderer.dvScatterFuncValues.Add(dvDataToShowAccDevDirection);
accDeviationDirectionRenderer.scatterLineColors.Add(new Bgr(Color.Blue));
accDeviationDirectionRenderer.scatterDrawingVariants.Add(SequencesDrawingVariants.polyline);
}
else
{
if (accDeviationDirectionRenderer.xSpaceMin != dvSecondsVector.Max() - sensorsHistoryRepresentingScale)
{
accDeviationDirectionRenderer.xSpaceMin = dvSecondsVector.Max() - sensorsHistoryRepresentingScale;
accDeviationDirectionRenderer.dvScatterXSpace.Clear();
accDeviationDirectionRenderer.dvScatterFuncValues.Clear();
accDeviationDirectionRenderer.scatterLineColors.Clear();
accDeviationDirectionRenderer.scatterDrawingVariants.Clear();
accDeviationDirectionRenderer.dvScatterXSpace.Add(dvSecondsVector);
accDeviationDirectionRenderer.dvScatterFuncValues.Add(dvDataToShowAccDevDirection);
accDeviationDirectionRenderer.scatterLineColors.Add(new Bgr(Color.Blue));
accDeviationDirectionRenderer.scatterDrawingVariants.Add(SequencesDrawingVariants.polyline);
}
}
accDeviationDirectionRenderer.xSpaceMin = dvSecondsVector.Max() - sensorsHistoryRepresentingScale;
accDeviationDirectionRenderer.Represent();
ThreadSafeOperations.UpdatePictureBox(pbRepresentingDevDirection, accDeviationDirectionRenderer.TheImage.Bitmap);
}
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);
}
void bgwGraphsPresenter_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGraph, false, false, wcUpdatimgGraph.Color);
}
