示例#1
0
 public Spectrum(APISpectrum apiSpec)
 {
     SessionName    = apiSpec.SessionName;
     SessionIndex   = apiSpec.SessionIndex;
     Label          = "Spectrum " + SessionIndex;
     NumChannels    = apiSpec.NumChannels;
     Latitude       = apiSpec.Latitude;
     LatitudeError  = 0d;
     Longitude      = apiSpec.Longitude;
     LongitudeError = 0d;
     Altitude       = apiSpec.Altitude;
     AltitudeError  = 0d;
     GpsTime        = DateTime.ParseExact(apiSpec.StartTime, "dd.MM.yyyy HH:mm:ss", CultureInfo.InvariantCulture);
     GpsTrack       = (float)apiSpec.Track;
     GpsTrackError  = 0f;
     GpsSpeed       = (float)apiSpec.Speed;
     GpsSpeedError  = 0f;
     GpsClimb       = (float)apiSpec.Climb;
     GpsClimbError  = 0f;
     Realtime       = (int)apiSpec.Realtime;
     Livetime       = (int)apiSpec.Livetime;
     TotalCount     = 0f;
     Doserate       = apiSpec.Doserate;
     mChannels      = new List <float>();
     // Split channel string and store each count in channel array
     LoadSpectrumString(apiSpec.Channels);
 }
示例#2
0
        private void menuItemLoadSession_Click(object sender, EventArgs e)
        {
            FormSelectSession form = new FormSelectSession(parent, settings, log);

            if (form.ShowDialog() != DialogResult.OK)
            {
                return;
            }

            syncService.Deactivate();

            APISpectrum spec = new APISpectrum();

            while (recvq.TryDequeue(out spec))
            {
                ;
            }

            int idx;

            while (syncb.TryTake(out idx))
            {
                ;
            }

            parent.ClearSession();

            session = new Session(form.SelectedSession);

            parent.SetSession(session);

            syncArgs.WSAddress        = settings.LastUploadHostname;
            syncArgs.Username         = settings.LastUploadUsername;
            syncArgs.Password         = settings.LastUploadPassword;
            syncArgs.SessionName      = session.Name;
            syncArgs.LastSessionIndex = -1;

            syncService.Activate(syncArgs);

            progress.Maximum = form.SelectedSpectrumCount;
            progress.Value   = 0;
            progress.Visible = true;

            log.Info("Session " + session.Name + " loaded");
        }
示例#3
0
        public void DoWork()
        {
            try
            {
                log.Info("Initializing sync service");

                while (running)
                {
                    startTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

                    if (active && !String.IsNullOrEmpty(args.SessionName))
                    {
                        HttpWebRequest request     = (HttpWebRequest)WebRequest.Create(args.WSAddress + "/spectrums/" + args.SessionName + "?minIdx=" + (args.LastSessionIndex + 1) + "&maxCnt=300");
                        string         credentials = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(args.Username + ":" + args.Password));
                        request.Headers.Add("Authorization", "Basic " + credentials);
                        request.Timeout = 8000;
                        request.Method  = WebRequestMethods.Http.Get;
                        request.Accept  = "application/json";

                        string         data;
                        HttpStatusCode code = Utils.GetResponseData(request, out data);

                        if (code != HttpStatusCode.OK)
                        {
                            log.Error(code.ToString() + ": " + data);
                            active = false;
                            continue;
                        }

                        List <APISpectrum> spectrumList = JsonConvert.DeserializeObject <List <APISpectrum> >(data);
                        foreach (APISpectrum apiSpec in spectrumList)
                        {
                            if (!active)
                            {
                                break;
                            }

                            recvq.Enqueue(apiSpec);
                            if (apiSpec.SessionIndex > args.LastSessionIndex)
                            {
                                args.LastSessionIndex = apiSpec.SessionIndex;
                            }
                        }

                        // request sync specs
                        if (syncb.Count > 0)
                        {
                            int idx;
                            while (syncb.TryPeek(out idx))
                            {
                                if (!active)
                                {
                                    break;
                                }

                                request     = (HttpWebRequest)WebRequest.Create(args.WSAddress + "/spectrums/" + args.SessionName + "/" + idx.ToString());
                                credentials = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(args.Username + ":" + args.Password));
                                request.Headers.Add("Authorization", "Basic " + credentials);
                                request.Timeout = 8000;
                                request.Method  = WebRequestMethods.Http.Get;
                                request.Accept  = "application/json";

                                code = Utils.GetResponseData(request, out data);

                                if (code == HttpStatusCode.OK)
                                {
                                    int i;
                                    syncb.TryTake(out i);

                                    APISpectrum spectrum = JsonConvert.DeserializeObject <APISpectrum>(data);
                                    recvq.Enqueue(spectrum);
                                    log.Info("Synced spectrum " + spectrum.SessionIndex);
                                }
                                else
                                {
                                    log.Info("Sync failed, skipping");
                                    break;
                                }
                            }
                        }
                    }

                    currentTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

                    int delta     = (int)(currentTime - startTime);
                    int sleepTime = (delta < 3000) ? 3000 - delta : 0;
                    Thread.Sleep(sleepTime);
                }
            }
            catch (Exception ex)
            {
                log.Error(ex.Message, ex);
            }
        }
示例#4
0
        private bool dispatchRecvMsg(APISpectrum apiSpec)
        {
            // Handle messages received from network

            try
            {
                // Session spectrum received successfully
                Spectrum spec = new Spectrum(apiSpec);

                // Normal session spectrum received
                log.Info(spec.Label + " received");

                // Add spectrum to session
                if (session != null && session.IsLoaded && session.Name == spec.SessionName)
                {
                    session.Add(spec);

                    // Add spectrum to UI list
                    bool updateSelectedIndex = false;
                    if (lbSession.SelectedIndex == 0)
                    {
                        updateSelectedIndex = true;
                    }

                    int index = 0, last_index = 0;

                    for (int i = 0; i < lbSession.Items.Count; i++)
                    {
                        Spectrum s = lbSession.Items[i] as Spectrum;
                        last_index = s.SessionIndex;
                        if (last_index < spec.SessionIndex)
                        {
                            index = i;
                            break;
                        }
                    }

                    if (last_index > spec.SessionIndex)
                    {
                        lbSession.Items.Add(spec);
                    }
                    else
                    {
                        lbSession.Items.Insert(index, spec);
                    }

                    if (updateSelectedIndex)
                    {
                        lbSession.ClearSelected();
                        lbSession.SetSelected(0, true);
                    }

                    // Notify external forms about new spectrum

                    parent.AddSpectrum(spec);

                    if (session.Spectrums.Count == 1)
                    {
                        parent.PositionMap(spec.Latitude, spec.Longitude);
                    }

                    if (progress.Value < progress.Maximum)
                    {
                        progress.Value++;
                    }

                    if (progress.Value >= progress.Maximum)
                    {
                        progress.Visible = false;
                    }
                }
            }
            catch (Exception ex)
            {
                log.Error(ex.Message, ex);
                return(false);
            }

            return(true);
        }