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);
}
/// <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);
}
public static List <GpxReader.Trk> GetGpxTracks()
{
var xmlString = File.ReadAllText(Logic._client.Settings.GPXFile);
var readgpx = new GpxReader(xmlString);
return(readgpx.Tracks);
}
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());
}
private static List <GpxReader.Trk> GetGpxTracks(ISession session)
{
var xmlString = File.ReadAllText(session.LogicSettings.GpxFile);
var readgpx = new GpxReader(xmlString, session);
return(readgpx.Tracks);
}
/*
* private async Task LoadAndDisplayGpxFile()
* {
* var xmlString = File.ReadAllText(_clientSettings.GPXFile);
* var readgpx = new GpxReader(xmlString);
* foreach (var trk in readgpx.Tracks)
* {
* foreach (var trkseg in trk.Segments)
* {
* foreach (var trpkt in trkseg.TrackPoints)
* {
* Console.WriteLine(trpkt.ToString());
* }
* }
* }
* await Task.Delay(0);
* }
*/
/*
* private GPXReader.trk GetGPXTrack(string gpxFile)
* {
* string xmlString = File.ReadAllText(_clientSettings.GPXFile);
* GPXReader Readgpx = new GPXReader(xmlString);
* return Readgpx.Tracks.ElementAt(0);
* }
*/
private List <GpxReader.Trk> GetGpxTracks()
{
var xmlString = File.ReadAllText(_clientSettings.GPXFile);
var readgpx = new GpxReader(xmlString);
return(readgpx.Tracks);
}
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();
}
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 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 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 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 async Task<PlayerUpdateResponse> HumanPathWalking(GpxReader.Trkpt trk,
double walkingSpeedInKilometersPerHour, Func<Task> functionExecutedWhileWalking)
{
//PlayerUpdateResponse result = null;
var targetLocation = new GeoCoordinate(Convert.ToDouble(trk.Lat), Convert.ToDouble(trk.Lon));
var speedInMetersPerSecond = walkingSpeedInKilometersPerHour/3.6;
var sourceLocation = new GeoCoordinate(_client.CurrentLat, _client.CurrentLng);
var distanceToTarget = LocationUtils.CalculateDistanceInMeters(sourceLocation, targetLocation);
// Logger.Write($"Distance to target location: {distanceToTarget:0.##} meters. Will take {distanceToTarget/speedInMetersPerSecond:0.##} seconds!", LogLevel.Info);
var nextWaypointBearing = LocationUtils.DegreeBearing(sourceLocation, targetLocation);
var nextWaypointDistance = speedInMetersPerSecond;
var waypoint = LocationUtils.CreateWaypoint(sourceLocation, nextWaypointDistance, nextWaypointBearing,
Convert.ToDouble(trk.Ele));
//Initial walking
var requestSendDateTime = DateTime.Now;
var result =
await
_client.UpdatePlayerLocation(waypoint.Latitude, waypoint.Longitude, waypoint.Altitude);
do
{
var millisecondsUntilGetUpdatePlayerLocationResponse =
(DateTime.Now - requestSendDateTime).TotalMilliseconds;
sourceLocation = new GeoCoordinate(_client.CurrentLat, _client.CurrentLng);
var currentDistanceToTarget = LocationUtils.CalculateDistanceInMeters(sourceLocation, targetLocation);
//if (currentDistanceToTarget < 40)
//{
// if (speedInMetersPerSecond > SpeedDownTo)
// {
// //Logger.Write("We are within 40 meters of the target. Speeding down to 10 km/h to not pass the target.", LogLevel.Info);
// speedInMetersPerSecond = SpeedDownTo;
// }
//}
nextWaypointDistance = Math.Min(currentDistanceToTarget,
millisecondsUntilGetUpdatePlayerLocationResponse/1000*speedInMetersPerSecond);
nextWaypointBearing = LocationUtils.DegreeBearing(sourceLocation, targetLocation);
waypoint = LocationUtils.CreateWaypoint(sourceLocation, nextWaypointDistance, nextWaypointBearing);
requestSendDateTime = DateTime.Now;
result =
await
_client.UpdatePlayerLocation(waypoint.Latitude, waypoint.Longitude,
waypoint.Altitude);
if (functionExecutedWhileWalking != null)
await functionExecutedWhileWalking(); // look for pokemon
await Task.Delay(Math.Min((int) (distanceToTarget/speedInMetersPerSecond*1000), 3000));
} while (LocationUtils.CalculateDistanceInMeters(sourceLocation, targetLocation) >= 30);
return result;
}
public void Read_ThrowsExceptionIfWaypointHasntLon()
{
GpxReader target = new GpxReader(TestDataReader.Open("gpx-waypoint-without-lon.gpx"), new GpxReaderSettings()
{
ReadMetadata = false
});
Assert.Throws <InvalidDataException>(() => target.Read());
}
private static void Main(string[] args)
{
IGpxReader gpxReader = new GpxReader();
IKmlWriter kmlWriter = new KmlWriter();
ICommandLineParserService commandLineParserService = new CommandLineParserService();
IGpxToKmlConverter gpxToKmlConverter = new GpxToKmlConverter(commandLineParserService, gpxReader, kmlWriter);
gpxToKmlConverter.Run(args);
}
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_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 Constructor_StreamSettings_SetsSettingsAndMakesItReadOnly()
{
var settings = new GpxReaderSettings()
{
ReadMetadata = false
};
using (var target = new GpxReader(TestDataReader.Open("gpx-real-file.gpx"), settings)) {
Assert.Same(settings, target.Settings);
Assert.True(settings.IsReadOnly);
}
}
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_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_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_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()
{
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 Constructor_StreamSettings_SetsSettingsAndMakesItReadOnly()
{
var settings = new GpxReaderSettings()
{
ReadMetadata = false
};
using (var target = new GpxReader(new MemoryStream(GpxTestData.gpx_real_file), settings)) {
Assert.Same(settings, target.Settings);
Assert.True(settings.IsReadOnly);
}
}
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_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_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_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 Dispose_ClosesOutputStreamIfWritingToStream()
{
var stream = new MemoryStream(GpxTestData.gpx_real_file);
var target = new GpxReader(stream, new GpxReaderSettings()
{
ReadMetadata = false
});
target.Dispose();
Assert.False(stream.CanRead);
}
/// <summary>
/// Loads Gpx data from a file.
/// </summary>
/// <param name="path">Path to the GPX file.</param>
/// <returns>GpxDocument instance with data from GPX file</returns>
public static GpxDocument Load(string path)
{
GpxDocument result = new GpxDocument();
using (GpxReader reader = new GpxReader(path, new GpxReaderSettings()
{
ReadMetadata = true
})) {
result.LoadFromReader(reader);
}
return(result);
}
public void Constructor_StringSettings_SetsSettingsAndMakesItReadOnly()
{
string path = "../../../Data/Gpx/gpx-real-file.gpx";
var settings = new GpxReaderSettings()
{
ReadMetadata = false
};
using (var target = new GpxReader(path, settings)) {
Assert.Same(settings, target.Settings);
Assert.True(settings.IsReadOnly);
}
}
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);
}
private static List<GpxReader.Trk> GetGpxTracks(ISession session)
{
var xmlString = File.ReadAllText(session.LogicSettings.GpxFile);
var readgpx = new GpxReader(xmlString, session);
return readgpx.Tracks;
}
private static List<GpxReader.Trk> GetGpxTracks(Context ctx)
{
var xmlString = File.ReadAllText(ctx.LogicSettings.GpxFile);
var readgpx = new GpxReader(xmlString, ctx);
return readgpx.Tracks;
}
public async Task<PlayerUpdateResponse> HumanPathWalking(GpxReader.Trkpt trk,
double walkingSpeedInKilometersPerHour, Action functionExecutedWhileWalking)
{
//PlayerUpdateResponse result = null;
var targetLocation = new GeoCoordinate(Convert.ToDouble(trk.Lat, CultureInfo.InvariantCulture), Convert.ToDouble(trk.Lon, CultureInfo.InvariantCulture));
var speedInMetersPerSecond = walkingSpeedInKilometersPerHour / 3.6;
var sourceLocation = new GeoCoordinate(_client.CurrentLatitude, _client.CurrentLongitude);
var distanceToTarget = LocationUtils.CalculateDistanceInMeters(sourceLocation, targetLocation);
// Logger.Write($"Distance to target location: {distanceToTarget:0.##} meters. Will take {distanceToTarget/speedInMetersPerSecond:0.##} seconds!", LogLevel.Info);
var nextWaypointBearing = LocationUtils.DegreeBearing(sourceLocation, targetLocation);
var nextWaypointDistance = speedInMetersPerSecond;
var waypoint = LocationUtils.CreateWaypoint(sourceLocation, nextWaypointDistance, nextWaypointBearing,
Convert.ToDouble(trk.Ele, CultureInfo.InvariantCulture));
//Initial walking
var requestSendDateTime = DateTime.Now;
PlayerUpdateResponse result;
await _player.UpdatePlayerLocation(waypoint.Latitude, waypoint.Longitude, waypoint.Altitude);
do
{
var millisecondsUntilGetUpdatePlayerLocationResponse =
(DateTime.Now - requestSendDateTime).TotalMilliseconds;
sourceLocation = new GeoCoordinate(_client.CurrentLatitude, _client.CurrentLongitude);
var currentDistanceToTarget = LocationUtils.CalculateDistanceInMeters(sourceLocation, targetLocation);
nextWaypointDistance = Math.Min(currentDistanceToTarget,
millisecondsUntilGetUpdatePlayerLocationResponse / 1000 * speedInMetersPerSecond);
nextWaypointBearing = LocationUtils.DegreeBearing(sourceLocation, targetLocation);
waypoint = LocationUtils.CreateWaypoint(sourceLocation, nextWaypointDistance, nextWaypointBearing);
requestSendDateTime = DateTime.Now;
result =
await
_player.UpdatePlayerLocation(waypoint.Latitude, waypoint.Longitude,
waypoint.Altitude);
functionExecutedWhileWalking?.Invoke(); // look for pokemon & hit stops
await Task.Delay(Math.Min((int)(distanceToTarget / speedInMetersPerSecond * 1000), 3000));
} while (LocationUtils.CalculateDistanceInMeters(sourceLocation, targetLocation) >= 30);
return result;
}
/*
private async Task LoadAndDisplayGpxFile()
{
var xmlString = File.ReadAllText(_clientSettings.GPXFile);
var readgpx = new GpxReader(xmlString);
foreach (var trk in readgpx.Tracks)
{
foreach (var trkseg in trk.Segments)
{
foreach (var trpkt in trkseg.TrackPoints)
{
Console.WriteLine(trpkt.ToString());
}
}
}
await Task.Delay(0);
}
*/
/*
private GPXReader.trk GetGPXTrack(string gpxFile)
{
string xmlString = File.ReadAllText(_clientSettings.GPXFile);
GPXReader Readgpx = new GPXReader(xmlString);
return Readgpx.Tracks.ElementAt(0);
}
*/
private List<GpxReader.Trk> GetGpxTracks()
{
var xmlString = File.ReadAllText(_clientSettings.GPXFile);
var readgpx = new GpxReader(xmlString);
return readgpx.Tracks;
}
