public void Read_ParsesMultipleRoutes()
{
var data = TestDataReader.Open("gpx-route-multiple-routes.gpx");
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result1 = target.Read() as GpxRoute;
var result2 = target.Read() as GpxRoute;
Assert.Equal(3, result1.Points.Count);
Assert.Equal(2, result2.Points.Count);
}
public void Read_ParsesMultipleRoutes()
{
MemoryStream data = new MemoryStream(GpxTestData.gpx_route_multiple_routes);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result1 = target.Read() as GpxRoute;
var result2 = target.Read() as GpxRoute;
Assert.Equal(3, result1.Points.Count);
Assert.Equal(2, result2.Points.Count);
}
private void newGpxFile(string Name, string Path)
{
FileStream readFile = File.Open(Path, FileMode.Open);
FileStream writeFile = File.OpenWrite("../../Files/" + Name);
GpxReader reader = new GpxReader(readFile);
GpxWriter writer = new GpxWriter(writeFile);
while (reader.Read())
{
switch (reader.ObjectType)
{
case GpxObjectType.Metadata:
writer.WriteMetadata(reader.Metadata);
break;
case GpxObjectType.WayPoint:
writer.WriteWayPoint(reader.WayPoint);
break;
case GpxObjectType.Route:
writer.WriteRoute(reader.Route);
break;
case GpxObjectType.Track:
writer.WriteTrack(reader.Track);
break;
}
}
readFile.Close();
writeFile.Close();
}
/// <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 static List <GpxTrackSegment> readGpx(string filename)
{
var result = new List <GpxTrackSegment>();
using (var input = new System.IO.FileStream(filename, System.IO.FileMode.Open, System.IO.FileAccess.Read))
{
using (GpxReader reader = new GpxReader(input))
{
while (reader.Read())
{
switch (reader.ObjectType)
{
case GpxObjectType.Metadata:
break;
case GpxObjectType.WayPoint:
break;
case GpxObjectType.Route:
break;
case GpxObjectType.Track:
result.AddRange(reader.Track.Segments);
break;
}
}
}
}
return(result);
}
public void Read_ReadsAllEntitiesFromRealGpxFile()
{
MemoryStream data = new MemoryStream(GpxTestData.gpx_real_file);
List <IGpxGeometry> parsed = new List <IGpxGeometry>();
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = true
});
IGpxGeometry geometry = null;
while ((geometry = target.Read()) != null)
{
parsed.Add(geometry);
}
// waypoints
Assert.Equal(3, parsed.Where(g => g.GeometryType == GpxGeometryType.Waypoint).Count());
// routes
Assert.Equal(2, parsed.Where(g => g.GeometryType == GpxGeometryType.Route).Count());
// tracks
Assert.Equal(1, parsed.Where(g => g.GeometryType == GpxGeometryType.Track).Count());
}
public void Load(Stream stream)
{
for (int i = 0; i < 10; i++)
{
activitySummary[i] = new List <XmlTimeline.Activity>();
}
// Loop
timelineItems.Clear();
GpxReader gpxReader = new GpxReader(stream);
while (gpxReader.Read())
{
switch (gpxReader.ObjectType)
{
case GpxObjectType.Metadata:
//gpxReader.Metadata;
break;
case GpxObjectType.WayPoint:
GetPlace(gpxReader.WayPoint);
break;
case GpxObjectType.Track:
GetMove(gpxReader.Track);
break;
}
}
SetStartEnd();
SetSummary();
SetXmlDate();
//Display();
}
public void Read_ReadsWaypointUnsortedMetadataAndExtension()
{
var data = TestDataReader.Open("gpx-waypoint-with-metadata.gpx");
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = true
});
var result = target.Read() as GpxPoint;
Assert.Equal(0.98, result.Metadata.MagVar);
Assert.Equal(12.5, result.Metadata.GeoidHeight);
Assert.Equal(GpsFix.Fix3D, result.Metadata.Fix);
Assert.Equal(8, result.Metadata.SatellitesCount);
Assert.Equal(5.1, result.Metadata.Hdop);
Assert.Equal(8.1, result.Metadata.Vdop);
Assert.Equal(10.8, result.Metadata.Pdop);
Assert.Equal(45, result.Metadata.AgeOfDgpsData);
Assert.Equal(124, result.Metadata.DgpsId);
Assert.Equal("WPT Comment", result.Metadata.Comment);
Assert.Equal("WPT Description", result.Metadata.Description);
Assert.Equal("WPT Name", result.Metadata.Name);
Assert.Equal("WPT Source", result.Metadata.Source);
Assert.Equal(1, result.Metadata.Links.Count);
GpxLink link = result.Metadata.Links.Single();
Assert.Equal("http://www.topografix.com", link.Url.OriginalString);
Assert.Equal("Link text", link.Text);
Assert.Equal("plain/text", link.Type);
}
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 Read_ReadsAllEntitiesFromRealGpxFile()
{
var data = TestDataReader.Open("gpx-real-file.gpx");
List <IGpxGeometry> parsed = new List <IGpxGeometry>();
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = true
});
IGpxGeometry geometry = null;
while ((geometry = target.Read()) != null)
{
parsed.Add(geometry);
}
// waypoints
Assert.Equal(3, parsed.Where(g => g.GeometryType == GpxGeometryType.Waypoint).Count());
// routes
Assert.Equal(2, parsed.Where(g => g.GeometryType == GpxGeometryType.Route).Count());
// tracks
Assert.Single(parsed.Where(g => g.GeometryType == GpxGeometryType.Track));
}
public void Read_ThrowsExceptionIfWaypointHasntLon()
{
GpxReader target = new GpxReader(TestDataReader.Open("gpx-waypoint-without-lon.gpx"), new GpxReaderSettings()
{
ReadMetadata = false
});
Assert.Throws <InvalidDataException>(() => target.Read());
}
public void Read_ThrowsExceptionIfWaypointHasntLon()
{
GpxReader target = new GpxReader(new MemoryStream(GpxTestData.gpx_waypoint_without_lon), new GpxReaderSettings()
{
ReadMetadata = false
});
Assert.Throws <InvalidDataException>(() => target.Read());
}
public void Read_SetsRouteMetadataToNullIfReadMetadataIsFalse()
{
MemoryStream data = new MemoryStream(GpxTestData.gpx_route_with_metadata);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxRoute;
Assert.Null(result.Metadata);
}
public void Read_ParsesSingleRouteWithExtensions()
{
MemoryStream data = new MemoryStream(GpxTestData.gpx_route_with_metadata_and_extensions);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxRoute;
Assert.Equal(3, result.Points.Count);
}
public void Read_ParsesEmptyRoute()
{
MemoryStream data = new MemoryStream(GpxTestData.gpx_route_empty);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxRoute;
Assert.Equal(0, result.Points.Count);
}
public void Read_ParsesEmptyTrack()
{
MemoryStream data = new MemoryStream(GpxTestData.gpx_track_empty);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxTrack;
Assert.Equal(0, result.Geometries.Count);
}
public void Read_SetsRouteMetadataToNullIfReadMetadataIsFalse()
{
var data = TestDataReader.Open("gpx-route-with-metadata.gpx");
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxRoute;
Assert.Null(result.Metadata);
}
public void Read_ParsesSingleRouteWithExtensions()
{
var data = TestDataReader.Open("gpx-route-with-metadata-and-extensions.gpx");
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxRoute;
Assert.Equal(3, result.Points.Count);
}
public void Read_ParsesEmptyTrack()
{
var data = TestDataReader.Open("gpx-track-empty.gpx");
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxTrack;
Assert.Empty(result.Geometries);
}
public void Read_ParsesEmptyRoute()
{
var data = TestDataReader.Open("gpx-route-empty.gpx");
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxRoute;
Assert.Empty(result.Points);
}
public void Read_DoesntSetMetadataIfReadMetadataIsFalse()
{
var data = TestDataReader.Open("gpx-waypoint-with-metadata.gpx");
var expectedCoordinate = new Coordinate(-71.119277, 42.438878);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxPoint;
Assert.Null(result.Metadata);
}
public void Read_SetsMetadataIfReadMetadataIsTrue()
{
var data = new MemoryStream(GpxTestData.gpx_waypoint_simple);
var expectedCoordinate = new Coordinate(-71.119277, 42.438878);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = true
});
var result = target.Read() as GpxPoint;
Assert.NotNull(result.Metadata);
}
public void Read_ParsesTrackWithEmptySegment()
{
var data = TestDataReader.Open("gpx-track-empty-track-segment.gpx");
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxTrack;
Assert.Single(result.Geometries);
Assert.Empty(result.Geometries[0].Points);
}
public void Read_ParsesMultipleTracks()
{
var data = TestDataReader.Open("gpx-track-multiple-tracks.gpx");
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result1 = target.Read() as GpxTrack;
var result2 = target.Read() as GpxTrack;
//segments - first track
Assert.Equal(2, result1.Geometries.Count);
//points in segments - first track
Assert.Equal(3, result1.Geometries[0].Points.Count);
Assert.Equal(2, result1.Geometries[1].Points.Count);
//segments - second track
Assert.Single(result2.Geometries);
//points in segments - second track
Assert.Equal(2, result2.Geometries[0].Points.Count);
}
public void Read_ParsesTrackWithEmptySegment()
{
MemoryStream data = new MemoryStream(GpxTestData.gpx_track_empty_track_segment);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxTrack;
Assert.Equal(1, result.Geometries.Count);
Assert.Empty(result.Geometries[0].Points);
}
public void Read_ParsesMultipleTracks()
{
MemoryStream data = new MemoryStream(GpxTestData.gpx_track_multiple_tracks);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result1 = target.Read() as GpxTrack;
var result2 = target.Read() as GpxTrack;
//segments - first track
Assert.Equal(2, result1.Geometries.Count);
//points in segments - first track
Assert.Equal(3, result1.Geometries[0].Points.Count);
Assert.Equal(2, result1.Geometries[1].Points.Count);
//segments - second track
Assert.Equal(1, result2.Geometries.Count);
//points in segments - second track
Assert.Equal(2, result2.Geometries[0].Points.Count);
}
public void Read_DoesntSetMetadataIfReadMetadataIsFalse()
{
var data = new MemoryStream(GpxTestData.gpx_waypoint_with_metadata);
var expectedCoordinate = new Coordinate(-71.119277, 42.438878);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxPoint;
Assert.Null(result.Metadata);
}
public void Read_SetsMetadataIfReadMetadataIsTrue()
{
var data = TestDataReader.Open("gpx-waypoint-simple.gpx");
var expectedCoordinate = new Coordinate(-71.119277, 42.438878);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = true
});
var result = target.Read() as GpxPoint;
Assert.NotNull(result.Metadata);
}
public void Read_ParsesTrackWithSingleSegmentAndExtensions()
{
MemoryStream data = new MemoryStream(GpxTestData.gpx_track_single_track_segment);
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxTrack;
Assert.Equal(1, result.Geometries.Count);
GpxTrackSegment segment = result.Geometries[0];
}
public void Read_ParsesTrackWithSingleSegmentAndExtensions()
{
var data = TestDataReader.Open("gpx-track-single-track-segment.gpx");
GpxReader target = new GpxReader(data, new GpxReaderSettings()
{
ReadMetadata = false
});
var result = target.Read() as GpxTrack;
Assert.Single(result.Geometries);
GpxTrackSegment segment = result.Geometries[0];
}
