Beispiel #1
0
        public App()
        {
            UnhandledException += Application_UnhandledException;

            if (System.Diagnostics.Debugger.IsAttached)
            {
                // Zähler für die aktuelle Bildrate anzeigen.
                //Application.Current.Host.Settings.EnableFrameRateCounter = true;

                // Bereiche der Anwendung hervorheben, die mit jedem Bild neu gezeichnet werden.
                //Application.Current.Host.Settings.EnableRedrawRegions = true;

                // Nicht produktiven Visualisierungsmodus für die Analyse aktivieren, 
                // in dem GPU-beschleunigte Bereiche der Seite farbig hervorgehoben werden.
                //Application.Current.Host.Settings.EnableCacheVisualization = true;
            }

            InitializeComponent();

            InitializePhoneApplication();

            if (Microsoft.Devices.Environment.DeviceType == Microsoft.Devices.DeviceType.Emulator)
                lastKnownPosition = new GeoPosition<GeoCoordinate>(DateTimeOffset.Now, 
                    new GeoCoordinate(48.422362, 9.957327));
        }
        /// <summary>
        ///     Starts processing of nmea file using passed delay action.
        ///     Send GeoPosition message to message bus.
        /// </summary>
        public void Start(Action<TimeSpan> delayAction)
        {
            _positionDateTime = null;
            _position = new GeoPosition();
            string line;
            _isStarted = true;
            while ((line = _parser.ReadLine()) != null)
            {
                if (!_isStarted) break;

                if (line.Length <= 0) continue;

                var message = _parser.ParseLine(line);
                if (message == null || !CanSetPositionFromMessage(message) || _position.Date.Year < 2001)
                    continue;

                DateTime currentDateTime = _position.DateTime;
                if (_positionDateTime != null)
                {
                    var sleepTime = currentDateTime - _positionDateTime.Value;
                    delayAction(sleepTime);
                    _messageBus.Send(_position);
                }
                _positionDateTime = currentDateTime;
            }
            _isStarted = false;
            FireDone();
        }
Beispiel #3
0
 public Pushpin(GeoPosition<GeoCoordinate> position, string type, GeoPosition<GeoCoordinate> referencePosition = null, RoutedEventHandler pushpinEvent = null)
 {
     _referencePosition = referencePosition;
     _pushpinEvent = pushpinEvent;
     _position = position;
     _type = type;
     _pushpinOverlay = GetPushpinOverlay();
 }
 public void ChangePosition(DateTimeOffset offset, GeoCoordinate coordinate)
 {
     Position = new GeoPosition<GeoCoordinate>(offset, coordinate);
     if (PositionChanged != null)
     {
         PositionChanged(null, new GeoPositionChangedEventArgs<GeoCoordinate>(Position));
     }
 }
 private void OnPositionAvailable(GeoPosition<GeoCoordinate> position)
 {
     if (PositionAvailable != null)
     {
         Deployment.Current.Dispatcher.BeginInvoke(() =>
                 PositionAvailable(this, new EventArgs<Location>(new Location(position.Location.Latitude, position.Location.Longitude))));
     }
 }
Beispiel #6
0
 /// <summary>
 /// Use a GeoPosition instance to populate a ParseObject
 /// </summary>
 /// <param name="g">the GeoPosition</param>
 /// <param name="p">the ParseObject</param>
 public static void GeoPositionSetParseObject(GeoPosition<GeoCoordinate> g, ParseObject p)
 {
     p[LOCATION] = new ParseGeoPoint(ToParseNaN(g.Location.Latitude), ToParseNaN(g.Location.Longitude));
     p[TIME_STAMP] = g.Timestamp.DateTime;
     p[ALTITUDE] = ToParseNaN(g.Location.Altitude);
     p[HORIZONTAL_ACCURACY] = ToParseNaN(g.Location.HorizontalAccuracy);
     p[VERTICAL_ACCURACY] = ToParseNaN(g.Location.VerticalAccuracy);
     p[SPEED] = ToParseNaN(g.Location.Speed);
     p[COURSE] = ToParseNaN(g.Location.Course);
 }
Beispiel #7
0
        private const double R = 3440; //miglia nautiche

        #endregion Fields

        #region Methods

        /// <summary>
        /// Calcola la distanza in MIGLIA NAUTICHE (nm) tra due punti geografici. Il calcolo è svolto con la
        /// formula di Aversine
        /// </summary>
        /// <param name="pos1">punto uno</param>
        /// <param name="pos2">punto 2</param>
        /// <returns>la distanza in miglia nautiche</returns>
        public static double CalulateDistance(GeoPosition pos1, GeoPosition pos2)
        {
            double dLat = toRadian(pos2.Latitude - pos1.Latitude);
            double dLon = toRadian(pos2.Longitude - pos1.Longitude);
            double a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
                Math.Cos(toRadian(pos1.Latitude)) * Math.Cos(toRadian(pos2.Latitude)) *
                Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
            double c = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
            double d = R * c;
            return d;
        }
Beispiel #8
0
        void myWatcher_PositionChanged(object sender, GeoPositionChangedEventArgs<GeoCoordinate> e)
        {
             myPosition = myWatcher.Position;
             currentLocation = myWatcher.Position.Location;
             if (isInDriveMode)
             {
                 DrawMyCurrentRoute(currentLocation);
             }

             LocationManager.GetLocationName(UpdateLocation, myPosition.Location.Latitude.ToString(), myPosition.Location.Longitude.ToString());
        }
Beispiel #9
0
 private Position GetPosition(GeoPosition<GeoCoordinate> position)
 {
     if (position.Location.IsUnknown)
     {
         return null;
     }
     return new Position
                {
                    Latitude = position.Location.Latitude,
                    Longitude = position.Location.Longitude,
                    Speed = position.Location.Speed,
                    UtcTicks = position.Timestamp.UtcTicks
                };
 }
Beispiel #10
0
        public void Construction_with_course_lesser_than_zero_throws_execption()
        {
            var expectedTimestamp = TimeSpan.Zero;
            double expectedLatitude = -89.0;
            double expectedLongitude = 13.34046;
            double expectedPressureAltitude = 100.0;
            double expectedGpsAltitude = 101.0;
            double expectedCourse = -3.45;
            double expectedSpeed = 0.1;

            var coord = new GeoPosition(expectedTimestamp,
                                        expectedLatitude,
                                        expectedLongitude,
                                        expectedPressureAltitude,
                                        expectedGpsAltitude,
                                        expectedCourse,
                                        expectedSpeed);
        }
Beispiel #11
0
        public void Construction_with_latitude_smaller_than_90_throws_execption()
        {
            var expectedTimestamp = TimeSpan.Zero;
            double expectedLatitude = -90.5;
            double expectedLongitude = 13.34046;
            double expectedPressureAltitude = 100.0;
            double expectedGpsAltitude = 101.0;
            double expectedCourse = 3.45;
            double expectedSpeed = 30.0;

            var coord = new GeoPosition(expectedTimestamp,
                                        expectedLatitude,
                                        expectedLongitude,
                                        expectedPressureAltitude,
                                        expectedGpsAltitude,
                                        expectedCourse,
                                        expectedSpeed);
        }
Beispiel #12
0
            /// <summary>
            /// Convert a ParseObject to its GeoPosition counterpart
            /// </summary>
            /// <param name="p">the ParseObject instance</param>
            /// <returns>the GeoPosition object</returns>
            public static GeoPosition<GeoCoordinate> ParseObjectToGeoPosition(ParseObject p)
            {
                GeoPosition<GeoCoordinate> g = new GeoPosition<GeoCoordinate>();

                g.Timestamp = new DateTimeOffset(p.Get<DateTime>(TIME_STAMP));
                ParseGeoPoint pGeoPoint = p.Get<ParseGeoPoint>(LOCATION);

                g.Location = new GeoCoordinate();
                if (pGeoPoint.Latitude != NaNforParse)
                    g.Location.Latitude = pGeoPoint.Latitude;
                if (pGeoPoint.Longitude != NaNforParse)
                    g.Location.Longitude = pGeoPoint.Longitude;

                Double pAltitude = p.Get<Double>(ALTITUDE);
                if (pAltitude != NaNforParse)
                    g.Location.Altitude = pAltitude;

                Double pHAccuracy = p.Get<Double>(HORIZONTAL_ACCURACY);
                if (pHAccuracy != NaNforParse)
                    g.Location.HorizontalAccuracy = pHAccuracy;

                Double pVAccuracy = p.Get<Double>(VERTICAL_ACCURACY);
                if (pVAccuracy != NaNforParse)
                    g.Location.VerticalAccuracy = pVAccuracy;

                Double pSpeed = p.Get<Double>(SPEED);
                if (pSpeed != NaNforParse)
                    g.Location.Speed = pSpeed;

                Double pCourse = p.Get<Double>(COURSE);
                if (pCourse != NaNforParse)
                    g.Location.Course = pCourse;

                return g;
            }
    internal static Position GetPosition(GeoPosition<GeoCoordinate> position)
    {
      if (position.Location.IsUnknown)
        return null;

      var p = new Position();
      p.Accuracy = position.Location.HorizontalAccuracy;
      p.Longitude = position.Location.Longitude;
      p.Latitude = position.Location.Latitude;

      if (!Double.IsNaN(position.Location.VerticalAccuracy) && !Double.IsNaN(position.Location.Altitude))
      {
        p.AltitudeAccuracy = position.Location.VerticalAccuracy;
        p.Altitude = position.Location.Altitude;
      }

      if (!Double.IsNaN(position.Location.Course))
        p.Heading = position.Location.Course;

      if (!Double.IsNaN(position.Location.Speed))
        p.Speed = position.Location.Speed;

      p.Timestamp = position.Timestamp;

      return p;
    }
Beispiel #14
0
        private static void readRecordedData()
        {
            String name = "/WazeWP7;component/resources/points.csv";
            StreamResourceInfo ri = App.GetResourceStream(new Uri(name, UriKind.Relative));
            byte[] buffer = new byte[ri.Stream.Length];
            StreamReader sr = new StreamReader(ri.Stream);
            string s = sr.ReadLine();
            while (s != null)
            {
                string[] items = s.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                double longitude = double.Parse(items[0]);
                double latitude = double.Parse(items[1]);
                double speed = double.Parse(items[2]);
                double course = double.Parse(items[3]);
                DateTime time = DateTime.Parse(items[5]);

                GeoPosition<GeoCoordinate> position = new GeoPosition<GeoCoordinate>();
                position.Location = new GeoCoordinate();
                position.Location.Longitude = longitude;
                position.Location.Latitude = latitude;
                position.Location.Speed = speed;
                position.Location.Course = course;
                position.Timestamp = time;

                points.Add(position);

                s = sr.ReadLine();
            }
        }
Beispiel #15
0
        private void UpdatePosition(GeoPosition<GeoCoordinate> position)
        {
            try
            {
                int c_pos1 = CibylCallTable.getAddressByName("roadmap_gpsj2me_pos1");
                int c_pos2 = CibylCallTable.getAddressByName("roadmap_gpsj2me_pos2");

                UIWorker.addUIEvent(c_pos1,
                                    (int)(position.Location.Latitude * 1000000),
                                    (int)(position.Location.Longitude * 1000000),
                                    0,
                                    0, false);

                DateTime Now = DateTime.Now.ToUniversalTime();
                DateTime baseTime = new DateTime(1970, 1, 1, 0, 0, 0);
                long currentTimeMillis = (Now - baseTime).Ticks / 10000;

                UIWorker.addUIEvent(c_pos2,
                                    'A',
                                    //(int)(position.Timestamp.Ticks / 1000),
                                    //(int)DateTime.Now.Ticks / 10000 / 1000,
                                    (int)currentTimeMillis / 1000,
                                    (int)(position.Location.Speed * 2), // Convert to ~knots
                                    (int)position.Location.Course, false);

                if (meOnMapMenuItem != null)
                {
                    //meOnMapMenuItem.CallCallback();
                }

            }
            catch (Exception ex)
            {
                Logger.log("Exception in do_async_connect_cb: " + ex);
            }
        }
 public bool IsInside(GeoPosition position)
 {
     return GreatArc.Distance(_center, position) <= _radius;
 }
 public GeoCoordinateWatcher(GeoPositionAccuracy desiredAccuracy)
 {
     DesiredAccuracy = desiredAccuracy;
       Status = GeoPositionStatus.Initializing;
       Position = new GeoPosition<GeoCoordinate>(DateTimeOffset.Now, InitialPosition);
 }
		private void ProcessPosition(GeoPosition<GeoCoordinate> position)
		{
			if (position == null || position.Location == null || position.Location.IsUnknown)
			{
				return;
			}

			// Stores the new valid position.
			DeviceLocation = position.Location;

			// Uses the location's course if the compass is not enabled.
			if (!Compass.IsSupported)
			{
				DeviceHeading = position.Location.Course;
			}
		}
        private void ChangeStatusWithEvent(GeoPositionStatus status, GeoCoordinate currentLocation)
        {
            Position = new GeoPosition<GeoCoordinate>(DateTimeOffset.Now, currentLocation);
              ChangeStatusWithEvent(status);

              if (PositionChanged != null)
              {
            PositionChanged(this, new GeoPositionChangedEventArgs<GeoCoordinate>(Position));
              }
        }
        public GeoPosition<GeoCoordinate> GetCurrentLocation()
        {
            GeoCoordinateWatcher gcw = new GeoCoordinateWatcher();
            GeoPosition<GeoCoordinate> currentCoordinate = new GeoPosition<GeoCoordinate>();
            currentCoordinate.Location = new GeoCoordinate(47.627903, -122.143185);

            var CurrentLocation = gcw.Position;

            if (!CurrentLocation.Location.IsUnknown)
            {
                currentCoordinate.Location.Latitude = CurrentLocation.Location.Latitude;
                currentCoordinate.Location.Longitude = CurrentLocation.Location.Longitude;
            }

            return currentCoordinate;
        }
 public Circle(string id, GeoPosition center, Length radius)
 {
     _id = id;
     _center = center;
     _radius = radius;
 }
        /// <summary>
        /// Processed the watcher <see cref="GeoCoordinateWatcher.PositionChanged" /> event.
        /// </summary>
        /// <param name="e">The <see cref="GeoPositionChangedEventArgs{GeoCoordinate}" /> instance containing the event data.</param>
        protected override void OnPositionChanged(GeoPositionChangedEventArgs<GeoCoordinate> e)
        {
            _position = e.Position;

            if (_reportInterval == 0)
            {
                RaisePositionChangedEvent();
            }
        }
Beispiel #23
0
 private void TimerCallbackEmulator(object state)
 {
     if (point_index >= points.Count - 1)
         point_index = 0;
     last_position = points[point_index];
     last_update_time = DateTime.UtcNow;
     UpdatePosition(points[point_index++]);
 }
        private void RaisePositionChangedEvent()
        {
            var eventHandler = PositionChanged;
            var position = _position;

            if (eventHandler != null && position != null)
            {
                _position = null;

                var locationServicePosition = position.ToLocationServicePosition();

                eventHandler(this, new LocationServicePositionChangedEventArgs(locationServicePosition));
            }
        }
Beispiel #25
0
 public void gps_PositionChanged(object sender, GeoPositionChangedEventArgs<GeoCoordinate> e)
 {
     UpdatePosition(e.Position);
     last_update_time = DateTime.UtcNow;
     last_position = e.Position;
 }
		private void WatcherOnPositionChanged (object sender, GeoPositionChangedEventArgs<GeoCoordinate> e)
		{
			if (e.Position.Location.IsUnknown)
				return;

			bool isRecent = (e.Position.Timestamp - this.start).TotalMilliseconds < this.timeout;

			if (e.Position.Location.HorizontalAccuracy <= this.desiredAccuracy && isRecent)
				this.tcs.TrySetResult (Geolocator.GetPosition (e.Position));

			if (this.bestPosition == null || e.Position.Location.HorizontalAccuracy < this.bestPosition.Location.HorizontalAccuracy)
				this.bestPosition = e.Position;
		}
Beispiel #27
0
 protected bool Equals(GeoPosition other)
 {
     return Longitude.Equals(other.Longitude) && Latitude.Equals(other.Latitude);
 }
Beispiel #28
0
 void RefreshPosition(GeoPosition<GeoCoordinate> position)
 {
     _currLatitude = new Degree(position.Location.Latitude);
     _currLongitude = new Degree(position.Location.Longitude);
 }
        public int SaveFile(GeoPosition<GeoCoordinate> Position = null)
        {
            if (Position == null)
            {
                GeoCoordinateWatcher watcher = new GeoCoordinateWatcher(GeoPositionAccuracy.Default);
                watcher.Start();
                Position = watcher.Position;
            }

            var fileName = CurrentFileName();

            var tempFileName = "record.gpx.temp";
            var count = 0;
            bool firstRun = true;
            IsolatedStorageFile isStore = IsolatedStorageFile.GetUserStoreForApplication();
            if (isStore.FileExists(tempFileName))
            {
                isStore.DeleteFile(tempFileName);
            }
            if (isStore.FileExists(fileName))
            {
                firstRun = false;
                isStore.MoveFile(fileName, tempFileName);
            }

            using (IsolatedStorageFileStream input = new IsolatedStorageFileStream(tempFileName, System.IO.FileMode.OpenOrCreate, FileAccess.Read, isStore))
            using (IsolatedStorageFileStream output = new IsolatedStorageFileStream(fileName, System.IO.FileMode.OpenOrCreate, FileAccess.Write, isStore))
            using (GpxWriter writer = new GpxWriter(output))
            {
                GpxWayPoint last = null;
                if (!firstRun)
                {
                    using (GpxReader reader = new GpxReader(input))
                    {
                        while (reader.Read())
                        {
                            switch (reader.ObjectType)
                            {
                                case GpxObjectType.WayPoint:
                                    count++;
                                    writer.WriteWayPoint(reader.WayPoint);
                                    last = reader.WayPoint;
                                    break;
                            }
                        }
                    }
                }

                IsolatedStorageSettings.ApplicationSettings["LastLocation"] = last;
                IsolatedStorageSettings.ApplicationSettings.Save();

                if (double.IsNaN(Position.Location.Latitude) || double.IsNaN(Position.Location.Longitude))
                {
                    return count;
                }
                if (last == null || last.Time.ToString() != Position.Timestamp.UtcDateTime.ToString())
                {
                    writer.WriteWayPoint(new GpxWayPoint
                    {
                        Latitude = Position.Location.Latitude,
                        Longitude = Position.Location.Longitude,
                        Elevation = Position.Location.Altitude,
                        Time = Position.Timestamp.UtcDateTime,
                    });
                    count++;
                }
            }
            return count;
        }
 private void ParseCGA(NmeaMessage message)
 {
     GeoPosition position = new GeoPosition();
     double longitude = 0, latitude = 0;
     var f = (NmeaField) message.Fields[GGA.FieldIds.PositionFixIndicator];
     if ((f != null) && f.HasValue)
     {
         position.PositionFixIndicator = f.GetInt(position.PositionFixIndicator);
     }
     f = (NmeaField) message.Fields[GGA.FieldIds.X];
     if ((f != null) && f.HasValue)
     {
         longitude = f.GetDouble(_position.Coordinate.Longitude);
     }
     f = (NmeaField) message.Fields[GGA.FieldIds.Y];
     if ((f != null) && f.HasValue)
     {
         latitude = f.GetDouble(_position.Coordinate.Latitude);
     }
     f = (NmeaField) message.Fields[GGA.FieldIds.Utc];
     if ((f != null) && f.HasValue)
     {
         position.Time = f.GetTime(position.Time);
     }
     f = (NmeaField) message.Fields[GGA.FieldIds.Satelites];
     if ((f != null) && f.HasValue)
     {
         position.Satelites = f.GetInt(position.Satelites);
     }
     f = (NmeaField) message.Fields[GGA.FieldIds.Hdop];
     if ((f != null) && f.HasValue)
     {
         position.Hdop = f.GetInt(position.Hdop);
     }
     _position.Coordinate = new GeoCoordinate((float)latitude, (float)longitude);
 }