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();
}
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]);
}
}
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 void WriteTrack(GpxTrack track)
{
Writer_.WriteStartElement("trk");
WriteTrackOrRoute(track);
foreach (GpxTrackSegment segment in track.Segments)
{
WriteTrackSegment("trkseg", segment);
}
Writer_.WriteEndElement();
}
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);
}
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;
}
/// <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);
}
/// <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();
}
