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);
}
}
public GpxPointExt(GpxTrackPoint pt)
: base(pt)
{
Length = NOTVALID_DOUBLE;
Changed = false;
Deleted = false;
}
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.Fixes.Count];
for (var j = 0; j < segment.Fixes.Count; j++)
{
pts[j] = new GpxTrackPoint
{
lat = (decimal)segment.Fixes[j].Coordinate.Latitude,
lon = (decimal)segment.Fixes[j].Coordinate.Longitude,
ele = segment.Fixes[j].Coordinate.Is3D ? 0m : (decimal)((Is3D)segment.Fixes[j].Coordinate).Elevation
};
}
trk.trkseg[i] = new GpxTrackSegment {
trkpt = pts
};
}
yield return(trk);
}
}
public static TrackPoint Create(GpxTrackPoint gpxTrackPoint)
{
var trackPoint = new TrackPoint
{
Time = gpxTrackPoint.Time,
Elevation = gpxTrackPoint.Elevation,
Latitude = gpxTrackPoint.Latitude,
Longitude = gpxTrackPoint.Longitude
};
return(trackPoint);
}
private void WriteTrackPoint(GpxTrackPoint trackPoint)
{
Writer_.WriteStartElement("trkpt");
WritePoint(trackPoint);
if (trackPoint.HasExtensions)
{
Writer_.WriteStartElement("extensions");
Writer_.WriteStartElement("TrackPointExtension", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE);
if (trackPoint.Temperature != null)
{
Writer_.WriteElementString("atemp", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Temperature.Value.ToString());
}
if (trackPoint.WaterTemperature != null)
{
Writer_.WriteElementString("wtemp", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.WaterTemperature.Value.ToString());
}
if (trackPoint.Depth != null)
{
Writer_.WriteElementString("depth", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Depth.Value.ToString());
}
if (trackPoint.HeartRate != null)
{
Writer_.WriteElementString("hr", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.HeartRate.Value.ToString());
}
if (trackPoint.Cadence != null)
{
Writer_.WriteElementString("cad", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Cadence.Value.ToString());
}
if (trackPoint.Speed != null)
{
Writer_.WriteElementString("speed", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Speed.Value.ToString());
}
if (trackPoint.Course != null)
{
Writer_.WriteElementString("course", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Course.Value.ToString());
}
if (trackPoint.Bearing != null)
{
Writer_.WriteElementString("bearing", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Bearing.Value.ToString());
}
Writer_.WriteEndElement();
Writer_.WriteEndElement();
}
Writer_.WriteEndElement();
}
public static SqlGeography AsGeography(this GpxTrackPoint point)
{
SqlGeographyBuilder builder = new SqlGeographyBuilder();
builder.SetSrid(SridHelper.GeodeticWGS84);
builder.BeginGeography(OpenGisGeographyType.Point);
builder.BeginFigure(point.Latitude, point.Longitude);
builder.EndFigure();
builder.EndGeography();
return(builder.ConstructedGeography);
}
private void ReadTrackPointExtensions(GpxTrackPoint trackPoint)
{
if (reader.IsEmptyElement)
{
return;
}
string elementName = reader.Name;
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (reader.NamespaceURI == GpxNamespaces.GARMIN_EXTENSIONS_NAMESPACE ||
reader.NamespaceURI == GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V1_NAMESPACE ||
reader.NamespaceURI == GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE)
{
switch (reader.LocalName)
{
case "TrackPointExtension":
ReadGarminTrackPointExtensions(trackPoint);
break;
default:
SkipElement();
break;
}
break;
}
SkipElement();
break;
case XmlNodeType.EndElement:
if (reader.Name != elementName)
{
throw new FormatException(reader.Name);
}
return;
}
}
throw new FormatException(elementName);
}
private GpxTrackPoint ReadGpxTrackPoint()
{
string elementName = reader.Name;
bool isEmptyElement = reader.IsEmptyElement;
GpxTrackPoint trackPoint = new GpxTrackPoint();
GetPointLocation(trackPoint);
if (isEmptyElement)
{
return(trackPoint);
}
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.Name)
{
case "extensions":
ReadTrackPointExtensions(trackPoint);
break;
default:
if (!ProcessPointField(trackPoint))
{
SkipElement();
}
break;
}
break;
case XmlNodeType.EndElement:
if (reader.Name != elementName)
{
throw new FormatException(reader.Name);
}
return(trackPoint);
}
}
throw new FormatException(elementName);
}
private Node CreateAnimationFromGpx(string name, Node node, IEnumerable <GpxTrackPoint> points, float timeFactor)
{
timeFactor = timeFactor <= 0f ? 1f : timeFactor;
GpxTrackPoint initialPoint = points.First();
Vector3 initialPointVec3 = initialPoint.ToGeoPoint().ToVector3();
var translationCurve = points
.Select(p => ((float)(p.Time.Value - initialPoint.Time.Value).TotalSeconds / timeFactor
, (initialPointVec3 - p.ToGeoPoint().ToVector3())))
.ToArray();
node = node.WithTranslationAnimation(name, translationCurve);
// return new Vector3((float)geoPoint.Longitude, (float)geoPoint.Elevation, -(float)geoPoint.Latitude);
// up vector is (0,1,0)
double?lastBearing = points.FirstOrDefault(p => p.Bearing.HasValue)?.Bearing;
if (lastBearing.HasValue)
{
var rotationCurve = points
.Select(p =>
{
Matrix4x4 mat;
Quaternion quaternion = Quaternion.CreateFromAxisAngle(Vector3.UnitY, GetAngleRadians(lastBearing.Value, p.Bearing));
lastBearing = p.Bearing ?? lastBearing;
return((float)((p.Time.Value - initialPoint.Time.Value).TotalSeconds / timeFactor)
, quaternion);
})
.ToArray();
node = node.WithRotationAnimation(name + "rot", rotationCurve);
}
return(node);
}
private GpxTrackPoint ReadGpxTrackPoint(XmlReader reader)
{
GpxTrackPoint point = new GpxTrackPoint();
string elementName = reader.Name;
bool isEmptyElement = reader.IsEmptyElement;
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case "lat":
point.Latitude = double.Parse(reader.Value, CultureInfo.InvariantCulture.NumberFormat);
break;
case "lon":
point.Longitude = double.Parse(reader.Value, CultureInfo.InvariantCulture.NumberFormat);
break;
}
}
if (isEmptyElement) return point;
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.Name)
{
case "ele":
point.Elevation = ReadContentAsDouble(reader);
break;
case "time":
point.Time = ReadContentAsDateTime(reader);
break;
case "magvar":
point.MagneticVar = ReadContentAsDouble(reader);
break;
case "geoidheight":
point.GeoidHeight = ReadContentAsDouble(reader);
break;
case "fix":
point.FixType = ReadContentAsString(reader);
break;
case "sat":
point.Satelites = ReadContentAsInt(reader);
break;
case "hdop":
point.Hdop = ReadContentAsDouble(reader);
break;
case "vdop":
point.Vdop = ReadContentAsDouble(reader);
break;
case "pdop":
point.Pdop = ReadContentAsDouble(reader);
break;
case "ageofdgpsdata":
point.AgeOfData = ReadContentAsDouble(reader);
break;
case "dgpsid":
point.DgpsId = ReadContentAsInt(reader);
break;
case "extensions":
ReadTrackPointExtensions(reader);
break;
case "name":
case "cmt":
case "desc":
case "src":
case "link":
case "sym":
case "type":
SkipElement(reader);
break;
default:
throw new FormatException(reader.Name);
}
break;
case XmlNodeType.EndElement:
if (reader.Name != elementName) throw new FormatException(reader.Name);
return point;
}
}
throw new FormatException(elementName);
}
public static GeoPoint ToGeoPoint(this GpxTrackPoint pt)
{
return(new GeoPoint(pt.Latitude, pt.Longitude, pt.Elevation));
}
private static GeoPoint ConvertGpsPoint(GpxTrackPoint pt)
{
return(new GeoPoint(pt.Latitude, pt.Longitude, pt.Elevation));
}
private void ReadGarminTrackPointExtensions(GpxTrackPoint trackPoint)
{
if (reader.IsEmptyElement)
{
return;
}
string elementName = reader.Name;
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.LocalName)
{
case "Temperature":
case "atemp":
trackPoint.Temperature = reader.ReadElementContentAsDouble();
break;
case "wtemp":
trackPoint.WaterTemperature = reader.ReadElementContentAsDouble();
break;
case "Depth":
case "depth":
trackPoint.Depth = reader.ReadElementContentAsDouble();
break;
case "hr":
trackPoint.HeartRate = reader.ReadElementContentAsInt();
break;
case "cad":
trackPoint.Cadence = reader.ReadElementContentAsInt();
break;
case "speed":
trackPoint.Speed = reader.ReadElementContentAsDouble();
break;
case "course":
trackPoint.Course = reader.ReadElementContentAsDouble();
break;
case "bearing":
trackPoint.Bearing = reader.ReadElementContentAsDouble();
break;
default:
reader.SkipElement();
break;
}
break;
case XmlNodeType.EndElement:
if (reader.Name != elementName)
{
throw new FormatException(reader.Name);
}
return;
}
}
throw new FormatException(elementName);
}
private void ReadGarminTrackPointExtensions(GpxTrackPoint trackPoint)
{
if (Reader_.IsEmptyElement) return;
string elementName = Reader_.Name;
while (Reader_.Read())
{
switch (Reader_.NodeType)
{
case XmlNodeType.Element:
switch (Reader_.LocalName)
{
case "Temperature":
case "atemp":
trackPoint.Temperature = ReadContentAsDouble();
break;
case "wtemp":
trackPoint.WaterTemperature = ReadContentAsDouble();
break;
case "Depth":
case "depth":
trackPoint.Depth = ReadContentAsDouble();
break;
case "hr":
trackPoint.HeartRate = ReadContentAsInt();
break;
case "cad":
trackPoint.Cadence = ReadContentAsInt();
break;
case "speed":
trackPoint.Speed = ReadContentAsDouble();
break;
case "course":
trackPoint.Course = ReadContentAsDouble();
break;
case "bearing":
trackPoint.Bearing = ReadContentAsDouble();
break;
default:
SkipElement();
break;
}
break;
case XmlNodeType.EndElement:
if (Reader_.Name != elementName) throw new FormatException(Reader_.Name);
return;
}
}
throw new FormatException(elementName);
}
private void ReadTrackPointExtensions(GpxTrackPoint trackPoint)
{
if (Reader_.IsEmptyElement) return;
string elementName = Reader_.Name;
while (Reader_.Read())
{
switch (Reader_.NodeType)
{
case XmlNodeType.Element:
if (Reader_.NamespaceURI == GpxNamespaces.GARMIN_EXTENSIONS_NAMESPACE ||
Reader_.NamespaceURI == GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V1_NAMESPACE ||
Reader_.NamespaceURI == GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE)
{
switch (Reader_.LocalName)
{
case "TrackPointExtension":
ReadGarminTrackPointExtensions(trackPoint);
break;
default:
SkipElement();
break;
}
break;
}
SkipElement();
break;
case XmlNodeType.EndElement:
if (Reader_.Name != elementName) throw new FormatException(Reader_.Name);
return;
}
}
throw new FormatException(elementName);
}
private static GeoPoint ConvertGpsPoint(GpxTrackPoint pt)
{
return(new GeoPoint(pt.Latitude, pt.Longitude, (float)pt.Elevation.GetValueOrDefault(0), 0, 0));
}
private void WriteTrackPoint(string elementName, GpxTrackPoint trackPoint)
{
Writer_.WriteStartElement(elementName);
Writer_.WriteAttributeString("lat", trackPoint.Latitude.ToString(CultureInfo.InvariantCulture));
Writer_.WriteAttributeString("lon", trackPoint.Longitude.ToString(CultureInfo.InvariantCulture));
if (trackPoint.Elevation != default(double)) Writer_.WriteElementString("ele", trackPoint.Elevation.ToString(CultureInfo.InvariantCulture));
if (trackPoint.Time != default(DateTime)) Writer_.WriteElementString("time", ToGpxDateString(trackPoint.Time));
if (trackPoint.MagneticVar != default(double)) Writer_.WriteElementString("magvar", trackPoint.MagneticVar.ToString(CultureInfo.InvariantCulture));
if (trackPoint.GeoidHeight != default(double)) Writer_.WriteElementString("geoidheight", trackPoint.GeoidHeight.ToString(CultureInfo.InvariantCulture));
if (!string.IsNullOrEmpty(trackPoint.FixType)) Writer_.WriteElementString("fix", trackPoint.FixType);
if (trackPoint.Satelites != default(int)) Writer_.WriteElementString("sat", trackPoint.Satelites.ToString(CultureInfo.InvariantCulture));
if (trackPoint.Hdop != default(double)) Writer_.WriteElementString("hdop", trackPoint.Hdop.ToString(CultureInfo.InvariantCulture));
if (trackPoint.Vdop != default(double)) Writer_.WriteElementString("vdop", trackPoint.Vdop.ToString(CultureInfo.InvariantCulture));
if (trackPoint.Pdop != default(double)) Writer_.WriteElementString("pdop", trackPoint.Pdop.ToString(CultureInfo.InvariantCulture));
if (trackPoint.AgeOfData != default(double)) Writer_.WriteElementString("ageofdgpsdata", trackPoint.AgeOfData.ToString(CultureInfo.InvariantCulture));
if (trackPoint.DgpsId != default(int)) Writer_.WriteElementString("dgpsid", trackPoint.DgpsId.ToString(CultureInfo.InvariantCulture));
Writer_.WriteEndElement();
}
private void WriteTrackPoint(GpxTrackPoint trackPoint)
{
Writer_.WriteStartElement("trkpt");
WritePoint(trackPoint);
if (trackPoint.HasExtensions)
{
Writer_.WriteStartElement("extensions");
Writer_.WriteStartElement("TrackPointExtension", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE);
if (trackPoint.Temperature != null) Writer_.WriteElementString("atemp", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Temperature.Value.ToString());
if (trackPoint.WaterTemperature != null) Writer_.WriteElementString("wtemp", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.WaterTemperature.Value.ToString());
if (trackPoint.Depth != null) Writer_.WriteElementString("depth", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Depth.Value.ToString());
if (trackPoint.HeartRate != null) Writer_.WriteElementString("hr", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.HeartRate.Value.ToString());
if (trackPoint.Cadence != null) Writer_.WriteElementString("cad", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Cadence.Value.ToString());
if (trackPoint.Speed != null) Writer_.WriteElementString("speed", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Speed.Value.ToString());
if (trackPoint.Course != null) Writer_.WriteElementString("course", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Course.Value.ToString());
if (trackPoint.Bearing != null) Writer_.WriteElementString("bearing", GpxNamespaces.GARMIN_TRACKPOINT_EXTENSIONS_V2_NAMESPACE, trackPoint.Bearing.Value.ToString());
Writer_.WriteEndElement();
Writer_.WriteEndElement();
}
Writer_.WriteEndElement();
}
private GpxTrackPoint ReadGpxTrackPoint()
{
string elementName = Reader_.Name;
bool isEmptyElement = Reader_.IsEmptyElement;
GpxTrackPoint trackPoint = new GpxTrackPoint();
GetPointLocation(trackPoint);
if (isEmptyElement) return trackPoint;
while (Reader_.Read())
{
switch (Reader_.NodeType)
{
case XmlNodeType.Element:
switch (Reader_.Name)
{
case "extensions":
ReadTrackPointExtensions(trackPoint);
break;
default:
if (!ProcessPointField(trackPoint)) SkipElement();
break;
}
break;
case XmlNodeType.EndElement:
if (Reader_.Name != elementName) throw new FormatException(Reader_.Name);
return trackPoint;
}
}
throw new FormatException(elementName);
}
/// <summary>
/// Punktabstand
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <returns></returns>
public static double PointDistance(GpxTrackPoint p1, GpxTrackPoint p2)
{
return(GeoHelper.Wgs84Distance(p1.Lon, p2.Lon, p1.Lat, p2.Lat, GeoHelper.Wgs84DistanceCompute.ellipsoid));
}
