Example #1
0
        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();
        }
Example #2
0
        //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);
        }
Example #3
0
        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();
        }
Example #4
0
        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);
        }
Example #5
0
        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();
            //}
        }
Example #6
0
        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);
        }
Example #7
0
 void bgwGraphsPresenter_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
 {
     ThreadSafeOperations.SetLoadingCircleState(wcUpdatimgGraph, false, false, wcUpdatimgGraph.Color);
 }
Example #8
0
        //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();
            //}
            //}
        }