public static SqlGeography AsGeography(this GpxTrack track) { SqlGeographyBuilder builder = new SqlGeographyBuilder(); builder.SetSrid(SridHelper.GeodeticWGS84); builder.BeginGeography(OpenGisGeographyType.MultiLineString); foreach (var item in track.Segments) { if (item.TrackPoints.Count < 2) { continue; } AddTrackSegment(builder, item); //builder.BeginFigure(item.TrackPoints[0].Latitude, item.TrackPoints[0].Longitude); //for (int i = 1; i < item.TrackPoints.Count; i++) //{ // builder.AddLine(item.TrackPoints[i].Latitude, item.TrackPoints[i].Longitude); //} //builder.EndFigure(); } builder.EndGeography(); return(builder.ConstructedGeography.STIsValid().Value ? builder.ConstructedGeography : builder.ConstructedGeography.MakeValid()); }
private IEnumerable <GpxTrack> SerializeTracks(GpsData data) { foreach (var track in data.Tracks) { var trk = new GpxTrack(); SerializeTrackMetadata(track, trk, x => x.Name, (gpx, s) => gpx.name = s); SerializeTrackMetadata(track, trk, x => x.Description, (gpx, s) => gpx.desc = s); SerializeTrackMetadata(track, trk, x => x.Comment, (gpx, s) => gpx.cmt = s); trk.trkseg = new GpxTrackSegment[track.Segments.Count]; for (var i = 0; i < track.Segments.Count; i++) { var segment = track.Segments[i]; var pts = new GpxTrackPoint[segment.Waypoints.Count]; for (var j = 0; j < segment.Waypoints.Count; j++) { pts[j] = ConvertToGpxTrackPoint(segment.Waypoints[j]); } trk.trkseg[i] = new GpxTrackSegment { trkpt = pts }; } yield return(trk); } }
private static GpxTrack readTrack<TTrackPoint>(string path, IGpxTrackPointReader<TTrackPoint> trackPointReader = null) where TTrackPoint : GpxTrackPoint, new() { GpxTrack track = null; using (GpxIOFactory.CreateReader(path, trackPointReader, out IGpxReader reader, out _)) { while (reader.Read(out GpxObjectType type)) { switch (type) { case GpxObjectType.Metadata: break; case GpxObjectType.WayPoint: break; case GpxObjectType.Route: break; case GpxObjectType.Track: { if (track == null) track = reader.Track; else throw new InvalidOperationException("Track is already read"); break; } } } } if (track == null) throw new NullReferenceException("Track was not read"); return track; }
private static TrackActivity ConvertTrack(GpxTrack gpxTrack) { TrackActivity track = new TrackActivity(); track.Laps = new List <TrackLap>(); track.Waypoints = new List <TrackWaypoint>(); track.Name = gpxTrack.Name; track.Description = gpxTrack.Description; foreach (GpxTrackSegment segment in gpxTrack.TrackSegments) { TrackLap lap = new TrackLap(); lap.Points = new List <TrackPoint>(); foreach (GpxTrackPoint gpxPt in segment.TrackPoints) { TrackPoint pt = new TrackPoint(); pt.Latitude = (float)gpxPt.Lat; pt.Longitude = (float)gpxPt.Lon; pt.Altitude = (float)gpxPt.Elevation; pt.Time = gpxPt.Time; lap.Points.Add(pt); } track.Laps.Add(lap); } return(track); }
public static void ReadGPX(string fileName) { using (FileStream fs = new FileStream(fileName, FileMode.Open)) { using (GpxReader reader = new GpxReader(fs)) { while (reader.Read()) { switch (reader.ObjectType) { case GpxObjectType.Metadata: GpxMetadata metadata = reader.Metadata; Logger.Info("Metadata"); break; case GpxObjectType.WayPoint: GpxWayPoint waypoint = reader.WayPoint; Logger.Info("WayPoint"); break; case GpxObjectType.Route: GpxRoute route = reader.Route; Logger.Info("Route"); break; case GpxObjectType.Track: GpxTrack track = reader.Track; Logger.Info("Track"); break; } } } } }
public void TestSetup() { using (Stream gpxFileStream = SetupFileStream()) { _gpxTrack = GpxEngine.GetGpxTrackFromStream(gpxFileStream); } }
/// <summary> /// Read gpx file segments as enumerable GeoPoints /// </summary> /// <param name="gpxFileStream">GPX file stream</param> /// <returns></returns> public static IEnumerable <IEnumerable <T> > ReadGPX_Segments <T>(Stream gpxFileStream , Func <GpxTrackPoint, T> conversionFunc , Func <GpxRoutePoint, T> routeConversionFunc) { IEnumerable <IEnumerable <T> > segments = Enumerable.Empty <IEnumerable <T> >(); using (GpxReader reader = new GpxReader(gpxFileStream)) { while (reader.Read()) { switch (reader.ObjectType) { case GpxObjectType.Track: GpxTrack track = reader.Track; segments = segments.Concat(ConvertTrack(track, conversionFunc)); break; case GpxObjectType.Route: GpxRoute route = reader.Route; segments = segments.Concat(ConvertRoute(route, routeConversionFunc)); break; } } } return(segments); }
private IEnumerable <GpxTrack> SerializeTracks(GpsData data) { foreach (var track in data.Tracks) { var trk = new GpxTrack(); SerializeTrackMetadata(track, trk, x => x.Name, (gpx, s) => gpx.name = s); SerializeTrackMetadata(track, trk, x => x.Description, (gpx, s) => gpx.desc = s); SerializeTrackMetadata(track, trk, x => x.Comment, (gpx, s) => gpx.cmt = s); trk.trkseg = new GpxTrackSegment[track.Segments.Count]; for (var i = 0; i < track.Segments.Count; i++) { var segment = track.Segments[i]; var pts = new GpxWaypoint[segment.Fixes.Count]; for (var j = 0; j < segment.Fixes.Count; j++) { pts[j] = new GpxWaypoint { lat = (decimal)segment.Fixes[j].Coordinate.Latitude, lon = (decimal)segment.Fixes[j].Coordinate.Longitude, ele = segment.Fixes[j].Coordinate.Is3D ? (decimal)((Is3D)segment.Fixes[j].Coordinate).Elevation : 0m }; } trk.trkseg[i] = new GpxTrackSegment { trkpt = pts }; } yield return(trk); } }
private void LoadContentsOfGpxFile(HttpPostedFileBase file, ImportViewModel importViewModel) { try { GpxTrack track = GpxEngine.GetGpxTrackFromFile(file); if (track != null) { ExerciseSession session = ExerciseSession.Create(track); _db.ExerciseSessions.AddOrUpdate(s => s.Name, session); _db.SaveChanges(); importViewModel.FilesImported++; } else { importViewModel.FilesFailed.Add(new FailedFile { Filename = file.FileName, ErrorMessage = "File could not be processed." }); } } catch (Exception e) { _log.Error(string.Format("Failed to import file {0} with message: {1}", file.FileName, e.Message)); importViewModel.FilesFailed.Add(new FailedFile { Filename = file.FileName, ErrorMessage = e.Message }); } }
GpxWriter loadTrack(List <Track> tracks, Stream stream, string link_Href = "https://rutoteca.es/", string link_Text = "Rutoteca", string mimeType = "text/html", string name = "Rutoteca", string descripcion = "Visita Rutoteca el mayor almacen de rutas homologadas de España") { GpxWriter newGpx = new GpxWriter(stream); tracks.ForEach(t => { var newMetadata = new Gpx.GpxMetadata(); newMetadata.Link = new GpxLink(); newMetadata.Link.Href = link_Href; newMetadata.Link.MimeType = mimeType; newMetadata.Link.Text = link_Text; newMetadata.Name = name; newMetadata.Description = descripcion; newGpx.WriteMetadata(newMetadata); GpxTrack newTrack = new GpxTrack(); var newSegment = new Gpx.GpxTrackSegment(); var inicio = t.GpxPoint.First().Time; t.GpxPoint.ToList().ForEach(pt => { newSegment.TrackPoints.Add(SetGpxPoint(pt, inicio)); }); newTrack.Segments.Add(newSegment); newGpx.WriteTrack(newTrack); } ); return(newGpx); }
public void ReadingForcedExtensionTest() { GpxTrack track = readTrack("Data/forced-extension.gpx", new ProximityTrackPointReader()); Assert.Equal(DateTimeOffset.Parse("2002-01-25T15:11:00Z"), track.Segments.Single().TrackPoints[0].Time); Assert.Equal(6, (track.Segments.Single().TrackPoints[0] as ProximityTrackPoint).Proximity); Assert.Equal(DateTimeOffset.Parse("2002-01-25T15:11:01Z"), track.Segments.Single().TrackPoints[1].Time); Assert.Equal(12, (track.Segments.Single().TrackPoints[1] as ProximityTrackPoint).Proximity); }
public bool Read() { if (ObjectType == GpxObjectType.None) { return(false); } while (Reader_.Read()) { switch (Reader_.NodeType) { case XmlNodeType.Element: switch (Reader_.Name) { case "metadata": Metadata = ReadGpxMetadata(); ObjectType = GpxObjectType.Metadata; return(true); case "wpt": WayPoint = ReadGpxWayPoint(); ObjectType = GpxObjectType.WayPoint; return(true); case "rte": Route = ReadGpxRoute(); ObjectType = GpxObjectType.Route; return(true); case "trk": Track = ReadGpxTrack(); ObjectType = GpxObjectType.Track; return(true); default: SkipElement(); break; } break; case XmlNodeType.EndElement: if (Reader_.Name != "gpx") { throw new FormatException(Reader_.Name); } ObjectType = GpxObjectType.None; return(false); } } ObjectType = GpxObjectType.None; return(false); }
public void Constructor_Segments_CreateGpxTrackWithSegments() { GpxTrackSegment[] segments = new GpxTrackSegment[] { new GpxTrackSegment(), new GpxTrackSegment(), new GpxTrackSegment() }; GpxTrack target = new GpxTrack(segments); Assert.Equal(segments.Length, target.Geometries.Count); for (int i = 0; i < target.Geometries.Count; i++) { Assert.Same(segments[i], target.Geometries[i]); } }
public void WriteTrack(GpxTrack track) { Writer_.WriteStartElement("trk"); WriteTrackOrRoute(track); foreach (GpxTrackSegment segment in track.Segments) { WriteTrackSegment("trkseg", segment); } Writer_.WriteEndElement(); }
private GpxTrack[] CreateTracksFromMultiLineString(IFeature multiLineStringFeature) { var multiLineString = multiLineStringFeature.Geometry as MultiLineString; if (multiLineString == null) { return(new GpxTrack[0]); } var name = GetFeatureName(multiLineStringFeature); var description = GetFeatureDescription(multiLineStringFeature); var tracks = new List <GpxTrack>(); var nameIndex = 0; var list = new List <GpxTrackSegment>(); foreach (var lineString in multiLineString.Geometries.OfType <LineString>().Where(ls => ls.Coordinates.Any())) { var currentSegment = new GpxTrackSegment( new ImmutableGpxWaypointTable( lineString.Coordinates.Select(p => CreateWaypoint(p, null, null))), null); if (list.Count == 0) { list.Add(currentSegment); continue; } var lastPointInTrack = list.Last().Waypoints.Last(); var firstPointInSegment = currentSegment.Waypoints.First(); if (lastPointInTrack.Latitude.Equals(firstPointInSegment.Latitude) && lastPointInTrack.Longitude.Equals(firstPointInSegment.Longitude)) { list.Add(currentSegment); } else { // need to start a new track. var trackName = nameIndex == 0 ? name : name + " " + nameIndex; var newTrack = new GpxTrack(name: trackName, description: description, segments: list.ToImmutableArray(), classification: null, comment: null, source: null, links: ImmutableArray <GpxWebLink> .Empty, extensions: null, number: null); tracks.Add(newTrack); list.Clear(); list.Add(currentSegment); nameIndex++; } } var lastTackName = nameIndex == 0 ? name : name + " " + nameIndex; var lastTrack = new GpxTrack(name: lastTackName, description: description, segments: list.ToImmutableArray(), classification: null, comment: null, source: null, links: ImmutableArray <GpxWebLink> .Empty, extensions: null, number: null); tracks.Add(lastTrack); return(tracks.ToArray()); }
public GpxWriterTests() { _pointMetadata = new GpxPointMetadata(); _pointMetadata.AgeOfDgpsData = 45; _pointMetadata.DgpsId = 124; _pointMetadata.Fix = GpsFix.Fix3D; _pointMetadata.GeoidHeight = 12.5; _pointMetadata.Hdop = 5.1; _pointMetadata.MagVar = 0.98; _pointMetadata.Pdop = 10.8; _pointMetadata.SatellitesCount = 8; _pointMetadata.Symbol = "WPT Symbol"; _pointMetadata.Vdop = 8.1; _pointMetadata.Comment = "WPT Comment"; _pointMetadata.Description = "WPT Description"; _pointMetadata.Name = "WPT Name"; _pointMetadata.Source = "WPT Source"; _pointMetadata.Links.Add(new GpxLink(new Uri("http://www.topografix.com")) { Text = "Link text", Type = "plain/text" }); _waypointWithMetadata.Metadata = _pointMetadata; _routeMetadata = new GpxTrackMetadata(); _routeMetadata.Comment = "RTE Comment"; _routeMetadata.Description = "RTE Description"; _routeMetadata.Name = "RTE Name"; _routeMetadata.Source = "RTE Source"; _routeMetadata.Type = "RTE Type"; _routeMetadata.Links.Add(new GpxLink(new Uri("http://www.topografix.com")) { Text = "Link text", Type = "plain/text" }); _routeWithMetadata.Metadata = _routeMetadata; _trackMetadata = new GpxTrackMetadata(); _trackMetadata.Comment = "TRK Comment"; _trackMetadata.Description = "TRK Description"; _trackMetadata.Name = "TRK Name"; _trackMetadata.Source = "TRK Source"; _trackMetadata.Type = "TRK Type"; _trackMetadata.Links.Add(new GpxLink(new Uri("http://www.topografix.com")) { Text = "Link text", Type = "plain/text" }); _track = new GpxTrack(new GpxTrackSegment[] { _segment }); _trackWithMetadata = new GpxTrack(new GpxTrackSegment[] { _segment }); _trackWithMetadata.Metadata = _trackMetadata; }
private GpxTrack CreateNewTrack(GpxTrack track) { var newTrack = new GpxTrack() { Cmt = track.Cmt, Description = track.Description, Extensions = track.Extensions, Name = track.Name, Number = track.Number, Source = track.Source, Type = track.Type }; newTrack.Segments.Add(new GpxTrackSegment()); return(newTrack); }
private void ReadTrackExtensions(GpxTrack track) { if (reader.IsEmptyElement) { return; } string elementName = reader.Name; while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: if (reader.NamespaceURI == GpxNamespaces.GARMIN_EXTENSIONS_NAMESPACE) { switch (reader.LocalName) { case "TrackExtension": ReadGarminTrackOrRouteExtensions(track); break; default: reader.SkipElement(); break; } break; } reader.SkipElement(); break; case XmlNodeType.EndElement: if (reader.Name != elementName) { throw new FormatException(reader.Name); } return; } } throw new FormatException(elementName); }
public bool Read() { if (ObjectType == GpxObjectType.None) return false; while (Reader_.Read()) { switch (Reader_.NodeType) { case XmlNodeType.Element: switch (Reader_.Name) { case "metadata": Metadata = ReadGpxMetadata(); ObjectType = GpxObjectType.Metadata; return true; case "wpt": WayPoint = ReadGpxWayPoint(); ObjectType = GpxObjectType.WayPoint; return true; case "rte": Route = ReadGpxRoute(); ObjectType = GpxObjectType.Route; return true; case "trk": Track = ReadGpxTrack(); ObjectType = GpxObjectType.Track; return true; default: SkipElement(); break; } break; case XmlNodeType.EndElement: if (Reader_.Name != "gpx") throw new FormatException(Reader_.Name); ObjectType = GpxObjectType.None; return false; } } ObjectType = GpxObjectType.None; return false; }
public LoadedGpxFileTourInfo(LoadedGpxFile file, GpxTrack rawTrackData) { this.File = file; this.RawTrackData = rawTrackData; this.RawTrackOrRoute = rawTrackData; rawTrackData.Extensions ??= new GpxExtensions(); this.RawTourExtensionData = rawTrackData.Extensions.GetOrCreateExtension <TrackExtension>(); this.Segments = new List <LoadedGpxFileTourSegmentInfo>(rawTrackData.Segments.Count); foreach (var actSegment in rawTrackData.Segments) { this.Segments.Add(new LoadedGpxFileTourSegmentInfo(actSegment)); } this.Waypoints = file.Waypoints; this.CalculateTourMetrics(); }
/// <summary> /// Read gpx file segments as enumerable GeoPoints /// </summary> /// <param name="gpxFileStream">GPX file stream</param> /// <returns></returns> public static IEnumerable <IEnumerable <GeoPoint> > ReadGPX_Segments(Stream gpxFileStream) { IEnumerable <IEnumerable <GeoPoint> > segments = null; using (GpxReader reader = new GpxReader(gpxFileStream)) { while (reader.Read()) { switch (reader.ObjectType) { case GpxObjectType.Track: GpxTrack track = reader.Track; segments = ConvertTrack(track); break; } } } return(segments); }
private static IEnumerable <IEnumerable <GeoPoint> > ConvertTrack(GpxTrack track) { IEnumerable <IEnumerable <GeoPoint> > segments = null; if (track == null || track.Segments == null) { throw new ArgumentNullException("track", "Track is empty."); } try { segments = track.Segments.Select(seg => seg.TrackPoints.Select(pt => ConvertGpsPoint(pt))); } catch (Exception) { throw; } return(segments); }
private static IEnumerable <IEnumerable <T> > ConvertTrack <T>(GpxTrack track, Func <GpxTrackPoint, T> conversionFunc) { IEnumerable <IEnumerable <T> > segments = null; if (track == null || track.Segments == null) { throw new ArgumentNullException("track", "Track is empty."); } try { segments = track.Segments.Select(seg => seg.TrackPoints.Select(pt => conversionFunc(pt))); } catch (Exception) { throw; } return(segments); }
public static List <GpxTrack> Convert(string xmlFilePath) { List <GpxTrack> result = new List <GpxTrack>(); string xmlContent = File.ReadAllText(xmlFilePath); XmlDocument doc = new XmlDocument(); doc.LoadXml(xmlContent); // full document if (doc.HasChildNodes) { var gpx = doc.GetElementsByTagName("gpx"); foreach (XmlNode gpxNode in gpx) { GpxTrack track = new GpxTrack(); track.Track = new List <GpxTrackSegment>(); XmlNode metadata = GetChild(gpxNode, "metadata"); track.StartTime = GetChildValue(metadata, "time"); var tracks = GetChildren(gpxNode, "trk"); foreach (XmlNode trkNode in tracks) { var seg = GetChildren(trkNode, "trkseg"); foreach (XmlNode segNode in seg) { GpxTrackSegment segment = new GpxTrackSegment(); segment.Track = new List <GpxTrackpoint>(); var trackpoints = GetChildren(segNode, "trkpt"); foreach (XmlNode trackpointNode in trackpoints) { var trackpoint = LoadTrackpoint(trackpointNode); segment.Track.Add(trackpoint); } track.Track.Add(segment); } } result.Add(track); } } return(result); }
public void Save_IGpxWriter_WritesDataToWriter() { var waypoint = new GpxPoint(); var route = new GpxRoute(); var track = new GpxTrack(); Mock <IGpxWriter> writerM = new Mock <IGpxWriter>(); writerM.Setup(w => w.Write(waypoint)).Verifiable(); writerM.Setup(w => w.Write(route)).Verifiable(); writerM.Setup(w => w.Write(track)).Verifiable(); var target = new GpxDocument(new[] { waypoint }, new[] { route }, new[] { track }); target.Save(writerM.Object); writerM.Verify(w => w.Write(waypoint), Times.Once()); writerM.Verify(w => w.Write(route), Times.Once()); writerM.Verify(w => w.Write(track), Times.Once()); }
/// <summary> /// Reades a GPX track from the internal XmlReader /// </summary> /// <returns>the track parsed form the XmlReader</returns> private GpxTrack ReadTrack() { GpxTrack result = new GpxTrack(); if (_xmlReader.IsEmptyElement == false) { _xmlReader.Read(); GpxTrackMetadata metadata = null; if (this.Settings.ReadMetadata) { metadata = new GpxTrackMetadata(); } while ((_xmlReader.NodeType == XmlNodeType.EndElement && _xmlReader.Name == "trk") == false) { bool elementParsed = false; if (_xmlReader.Name == "trkseg") { GpxTrackSegment segment = ReadTrackSegment(); result.Geometries.Add(segment); elementParsed = true; } if (this.Settings.ReadMetadata) { elementParsed = elementParsed || this.TryReadTrackMetadata(metadata); } if (!elementParsed) { _xmlReader.Skip(); } } result.Metadata = metadata; } _xmlReader.Skip(); return(result); }
/// <summary> /// Tracks mit mehreren Segmenten splitten /// </summary> public void Segment2Track2() { int trackcount = TrackCount(); for (int t = 0; t < trackcount; t++) { int tracksegmentcount = TrackSegmentCount(t); if (tracksegmentcount > 1) { GpxTrack tr = GetPoorTrack(t, true); if (tr == null) { tr = new GpxTrack { Name = GetTrackname(t) }; while (TrackSegmentCount(t) > 1) { GpxTrackSegment ts = new GpxTrackSegment(); ts.Points.AddRange(GetTrackSegmentPointList(t, 1)); tr.Segments.Add(ts); } } while (TrackSegmentCount(t) > 1) { DeleteSegment(t, 1); } for (int s = 0; s < tr.Segments.Count; s++) { GpxTrack newtr = new GpxTrack(); newtr.Segments.Add(tr.Segments[s]); newtr.Name = CreateUniqueObjectName(newtr.Name, ObjectType.Track); InsertTrack(t + 1 + s, newtr); } t += tracksegmentcount - 1; trackcount += tracksegmentcount - 1; } } }
/// <summary> /// Writes the given track to the output stream /// </summary> /// <param name="track">The track to write</param> public void Write(GpxTrack track) { _xmlWriter.WriteStartElement("trk"); for (int i = 0; i < track.Geometries.Count; i++) { _xmlWriter.WriteStartElement("trkseg"); for (int ii = 0; ii < track.Geometries[i].Points.Count; ii++) { WritePoint(track.Geometries[i].Points[ii], "trkpt"); } _xmlWriter.WriteEndElement(); } if (this.Settings.WriteMetadata) { this.WriteTrackMetadata(track.Metadata); } _xmlWriter.WriteEndElement(); }
public static ExerciseSession Create(GpxTrack track) { var exerciseSession = new ExerciseSession { Name = track.Name, Time = track.Time }; ICollection <TrackSegment> trackSegments = new List <TrackSegment>(); foreach (var gpxTrackSegment in track.Segments) { trackSegments.Add(TrackSegment.Create(gpxTrackSegment)); } exerciseSession.Elevation = ElevationProcessor.SessionElevation(trackSegments); exerciseSession.Duration = DurationProcessor.SessionDuration(trackSegments); exerciseSession.Distance = DistanceProcessor.SessionDistance(trackSegments); exerciseSession.Calories = CaloriesProcessor.GetCaloriesBurned(exerciseSession); exerciseSession.Pace = PaceProcessor.GetAveragePace(exerciseSession); exerciseSession.ActivityType = ActivityProcessor.GetActivityType(exerciseSession); exerciseSession.Speed = SpeedProcessor.GetAverageSpeed(exerciseSession); exerciseSession.TrackSegments = trackSegments; return(exerciseSession); }
public static IEnumerable <IEnumerable <GeoPoint> > ReadGPX_Segments(string fileName) { IEnumerable <IEnumerable <GeoPoint> > segments = null; using (FileStream fs = new FileStream(fileName, FileMode.Open)) { using (GpxReader reader = new GpxReader(fs)) { while (reader.Read()) { switch (reader.ObjectType) { case GpxObjectType.Track: GpxTrack track = reader.Track; segments = ConvertTrack(track); Logger.Info("Track"); break; } } } } return(segments); }
private GpxTrack ReadGpxTrack(XmlReader reader) { GpxTrack track = new GpxTrack(); if (reader.IsEmptyElement) return track; string elementName = reader.Name; while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: switch (reader.Name) { case "name": track.Name = ReadContentAsString(reader); break; case "cmt": track.Comment = ReadContentAsString(reader); break; case "desc": track.Description = ReadContentAsString(reader); break; case "src": track.Source = ReadContentAsString(reader); break; case "link": track.Links.Add(ReadGpxLink(reader)); break; case "number": track.Number = int.Parse(ReadContentAsString(reader)); break; case "type": track.Type = ReadContentAsString(reader); break; case "extensions": ReadTrackExtensions(reader, track); break; case "trkseg": track.Segments.Add(ReadGpxTrackSegment(reader)); break; default: throw new FormatException(reader.Name); } break; case XmlNodeType.EndElement: if (reader.Name != elementName) throw new FormatException(reader.Name); return track; } } throw new FormatException(elementName); }
private void ReadTrackExtensions(XmlReader reader, GpxTrack track) { if (reader.IsEmptyElement) return; string elementName = reader.Name; while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: if (reader.LocalName == "TrackExtension" && reader.NamespaceURI == GARMIN_EXTENSIONS) { ReadGarminTrackOrRouteExtensions(reader, track); break; } SkipElement(reader); break; case XmlNodeType.EndElement: if (reader.Name != elementName) throw new FormatException(reader.Name); return; } } throw new FormatException(elementName); }
public void Constructor_Parameterless_CreateEmptyGpxTrack() { GpxTrack target = new GpxTrack(); Assert.Empty(target.Geometries); }
/// <summary> /// Reades a GPX track from the internal XmlReader /// </summary> /// <returns>the track parsed form the XmlReader</returns> private GpxTrack ReadTrack() { GpxTrack result = new GpxTrack(); if (_xmlReader.IsEmptyElement == false) { _xmlReader.Read(); GpxTrackMetadata metadata = null; if (this.Settings.ReadMetadata) { metadata = new GpxTrackMetadata(); } while ((_xmlReader.NodeType == XmlNodeType.EndElement && _xmlReader.Name == "trk") == false) { bool elementParsed = false; if (_xmlReader.Name == "trkseg") { GpxTrackSegment segment = ReadTrackSegment(); result.Geometries.Add(segment); elementParsed = true; } if (this.Settings.ReadMetadata) { elementParsed = elementParsed || this.TryReadTrackMetadata(metadata); } if (!elementParsed) { _xmlReader.Skip(); } } result.Metadata = metadata; } _xmlReader.Skip(); return result; }
public void GeometryType_ReturnsTrack() { GpxTrack target = new GpxTrack(); Assert.Equal(GpxGeometryType.Track, target.GeometryType); }
private void ReadTrackExtensions(GpxTrack track) { if (Reader_.IsEmptyElement) return; string elementName = Reader_.Name; while (Reader_.Read()) { switch (Reader_.NodeType) { case XmlNodeType.Element: if (Reader_.NamespaceURI == GpxNamespaces.GARMIN_EXTENSIONS_NAMESPACE) { switch (Reader_.LocalName) { case "TrackExtension": ReadGarminTrackOrRouteExtensions(track); break; default: SkipElement(); break; } break; } SkipElement(); break; case XmlNodeType.EndElement: if (Reader_.Name != elementName) throw new FormatException(Reader_.Name); return; } } throw new FormatException(elementName); }
public void Save_IGpxWriter_WritesDataToWriter() { var waypoint = new GpxPoint(); var route = new GpxRoute(); var track = new GpxTrack(); Mock<IGpxWriter> writerM = new Mock<IGpxWriter>(); writerM.Setup(w => w.Write(waypoint)).Verifiable(); writerM.Setup(w => w.Write(route)).Verifiable(); writerM.Setup(w => w.Write(track)).Verifiable(); var target = new GpxDocument(new[] { waypoint }, new[] { route }, new[] { track }); target.Save(writerM.Object); writerM.Verify(w => w.Write(waypoint), Times.Once()); writerM.Verify(w => w.Write(route), Times.Once()); writerM.Verify(w => w.Write(track), Times.Once()); }
private bool doRead() { if (this.Attributes == null) { ReadHeader(); return(true); } if (objectType == GpxObjectType.None) { return(false); } while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: switch (reader.Name) { case "metadata": Metadata = ReadGpxMetadata(); objectType = GpxObjectType.Metadata; return(true); case GpxSymbol.Waypoint: WayPoint = ReadGpxWayPoint(); objectType = GpxObjectType.WayPoint; return(true); case "rte": Route = ReadGpxRoute(); objectType = GpxObjectType.Route; return(true); case GpxSymbol.Track: Track = ReadGpxTrack(); objectType = GpxObjectType.Track; return(true); default: reader.SkipElement(); break; } break; case XmlNodeType.EndElement: if (reader.Name != "gpx") { throw new FormatException(reader.Name); } objectType = GpxObjectType.None; return(false); } } objectType = GpxObjectType.None; return(false); }