///<inheritdoc />
public FeatureCollection ToGeoJson(gpxType gpx)
{
var collection = new FeatureCollection();
var points = gpx.wpt ?? new wptType[0];
var pointsFeatures = points.Select(point => new Feature(new Point(CreateGeoPosition(point)), CreateProperties(point.name, point.desc)));
pointsFeatures.ToList().ForEach(f => collection.Features.Add(f));
var routes = gpx.rte ?? new rteType[0];
var routesFeatures = routes.Select(route => new Feature(new LineString(route.rtept.Select(CreateGeoPosition).ToArray()), CreateProperties(route.name, route.desc)));
routesFeatures.ToList().ForEach(f => collection.Features.Add(f));
foreach (var track in gpx.trk ?? new trkType[0])
{
if (track.trkseg.Length == 1)
{
var lineStringFeature = new Feature(new LineString(track.trkseg[0].trkpt.Select(CreateGeoPosition).ToArray()), CreateProperties(track.name, track.desc));
collection.Features.Add(lineStringFeature);
continue;
}
var lineStringList = track.trkseg.Select(segment => new LineString(segment.trkpt.Select(CreateGeoPosition).ToArray()) as ILineString).ToArray();
var feature = new Feature(new MultiLineString(lineStringList), CreateMultiLineProperties(track.name, gpx.creator, track.desc));
collection.Features.Add(feature);
}
return(collection);
}
public async Task <FavoriteRoute> LoadFromFile(StorageFile file)
{
var serializer = new XmlSerializer(typeof(gpxType));
Stream stream = await file.OpenStreamForReadAsync();
gpxType objectFromXml = (gpxType)serializer.Deserialize(stream);
stream.Dispose();
Name = (objectFromXml.metadata.name == null) ? "" : objectFromXml.metadata.name;
Description = (objectFromXml.metadata.desc == null) ? "" : objectFromXml.metadata.desc;
Timestamp = (objectFromXml.metadata.time == null) ? DateTime.Now : objectFromXml.metadata.time;
Symbol = (objectFromXml.metadata.extensions.symbol == null) ? "" : objectFromXml.metadata.extensions.symbol;
/*Address = (objectFromXml.metadata.extensions.address == null) ? "" : objectFromXml.metadata.extensions.address;*/
StartPoint = new BasicLocation()
{
Location = new Geopoint(new BasicGeoposition()
{
Latitude = (double)objectFromXml.wpt[0].lat,
Longitude = (double)objectFromXml.wpt[0].lon,
Altitude = (double)objectFromXml.wpt[0].ele
})
};
Track = objectFromXml.trk[0].trkseg[0].trkpt.Select(pos => new BasicGeoposition()
{
Latitude = (double)pos.lat,
Longitude = (double)pos.lon,
Altitude = (double)pos.ele
}).ToList();
return(this);
}
public void CovertTwoWays_OnlyOneRoute_ShouldBeTheSame()
{
gpxType gpx = new gpxType
{
rte = new [] { new rteType {
name = "route", rtept = new[]
{
new wptType {
lat = 1, lon = 2, ele = 3, eleSpecified = true
},
new wptType {
lat = 4, lon = 5
}
}
} },
};
var featureCollection = _gpxGeoJsonConverter.ToGeoJson(gpx);
var newGpx = _gpxGeoJsonConverter.ToGpx(featureCollection);
Assert.AreEqual(gpx.rte.Length, newGpx.rte.Length);
Assert.AreEqual(gpx.rte[0].name, newGpx.rte[0].name);
for (int i = 0; i < newGpx.rte[0].rtept.Length; i++)
{
Assert.AreEqual(gpx.rte[0].rtept[i].ele, newGpx.rte[0].rtept[i].ele);
Assert.AreEqual(gpx.rte[0].rtept[i].lat, newGpx.rte[0].rtept[i].lat);
Assert.AreEqual(gpx.rte[0].rtept[i].lon, newGpx.rte[0].rtept[i].lon);
}
}
public void TestInitialize()
{
_randomBytes = new byte[] { 0, 1, 1, 0 };
_simpleGpx = new gpxType { wpt = new[] { new wptType() } };
_gpsBabelGateway = Substitute.For<IGpsBabelGateway>();
_converterService = new DataContainerConverterService(_gpsBabelGateway, new GpxGeoJsonConverter(), new GpxDataContainerConverter(), new RouteDataSplitterService(new CoordinatesConverter()));
}
/// <summary>
/// Updates the bounds of a <see cref="gpxType"/> object according to internal data
/// </summary>
/// <param name="gpx">The <see cref="gpxType"/></param>
/// <returns>An updated <see cref="gpxType"/></returns>
public static gpxType UpdateBounds(this gpxType gpx)
{
if (gpx.metadata?.bounds != null &&
gpx.metadata.bounds.minlat != 0 &&
gpx.metadata.bounds.maxlat != 0 &&
gpx.metadata.bounds.minlon != 0 &&
gpx.metadata.bounds.maxlon != 0)
{
return(gpx);
}
var points = (gpx.rte ?? new rteType[0]).Where(r => r.rtept != null).SelectMany(r => r.rtept).ToArray();
points = points.Concat(gpx.wpt ?? new wptType[0]).ToArray();
points = points.Concat((gpx.trk ?? new trkType[0]).Where(r => r.trkseg != null).SelectMany(t => t.trkseg).SelectMany(s => s.trkpt)).ToArray();
if (!points.Any())
{
return(gpx);
}
if (gpx.metadata == null)
{
gpx.metadata = new metadataType {
bounds = new boundsType()
};
}
gpx.metadata.bounds = new boundsType
{
minlat = points.Min(p => p.lat),
maxlat = points.Max(p => p.lat),
minlon = points.Min(p => p.lon),
maxlon = points.Max(p => p.lon)
};
return(gpx);
}
public FeatureCollection ToGeoJson(gpxType gpx)
{
var collection = new FeatureCollection();
var points = gpx.wpt ?? new wptType[0];
var pointsFeatures = points.Select(point => new Feature(new Point(CreateGeoPosition(point)), CreateNameProperties(point.name)));
pointsFeatures.ToList().ForEach(f => collection.Features.Add(f));
var routes = gpx.rte ?? new rteType[0];
var routesFeatures = routes.Select(route => new Feature(new LineString(route.rtept.Select(CreateGeoPosition).ToArray()), CreateNameProperties(route.name)));
routesFeatures.ToList().ForEach(f => collection.Features.Add(f));
foreach (var track in gpx.trk ?? new trkType[0])
{
if (track.trkseg.Length == 1)
{
var lineStringFeature = new Feature(new LineString(track.trkseg[0].trkpt.Select(CreateGeoPosition).ToArray()), CreateNameProperties(track.name));
collection.Features.Add(lineStringFeature);
continue;
}
var lineStringList = track.trkseg.Select(segment => new LineString(segment.trkpt.Select(CreateGeoPosition).ToArray()) as ILineString).ToArray();
var feature = new Feature(new MultiLineString(lineStringList), CreateMultiLineProperties(track.name, gpx.creator));
collection.Features.Add(feature);
}
return collection;
}
public void PostGpsTrace_UrlProvidedForTrackGpxFile_ShouldReturnFeatureCollection()
{
var gpx = new gpxType
{
rte = new[]
{
new rteType
{
rtept = new[]
{
new wptType {lat = 0, lon = 0, timeSpecified = true, time = DateTime.Now},
new wptType {lat = 0.01M, lon = 0.01M, timeSpecified = true, time = DateTime.Now.AddMinutes(1)},
}
}
}
};
var url = SetupGpxUrl(gpx);
_controller.SetupIdentity();
var results = _controller.PostGpsTrace(url).Result as OkObjectResult;
Assert.IsNotNull(results);
var featureCollection = results.Value as FeatureCollection;
Assert.IsNotNull(featureCollection);
Assert.AreEqual(1, featureCollection.Features.Count);
Assert.IsTrue(featureCollection.Features.First().Attributes.GetValues().Contains("track"));
}
///<inheritdoc />
public DataContainer ToDataContainer(gpxType gpx)
{
gpx.UpdateBounds();
var container = new DataContainer
{
Routes = ConvertRoutesToRoutesData(gpx.rte ?? new rteType[0])
};
container.Routes.AddRange(ConvertTracksToRouteData(gpx.trk ?? new trkType[0]));
var nonEmptyWayPoints = gpx.wpt ?? new wptType[0];
var markers = nonEmptyWayPoints.Select(ToMarkerData).ToList();
if (markers.Any())
{
if (!container.Routes.Any())
{
var title = string.IsNullOrWhiteSpace(markers.First().Title) ? "Markers" : markers.First().Title;
var name = markers.Count == 1 ? title : "Markers";
container.Routes.Add(new RouteData {
Name = name, Description = nonEmptyWayPoints.First().desc
});
}
container.Routes.First().Markers = markers;
}
if (gpx.metadata?.bounds != null)
{
UpdateBoundingBox(container, gpx.metadata.bounds);
}
return(container);
}
public static GraphicCollection LoadGraphics( gpxType source )
{
source.RequireArgument<gpxType>( "source" ).NotNull<gpxType>();
GraphicCollection graphics = new GraphicCollection();
if( source == null )
return graphics;
if( source.wpt != null )
{
GraphicCollection gcs = LoadWayPoints( source.wpt );
gcs.ForEach<Graphic>( g => graphics.Add(g) );
}
if( source.rte != null )
{
GraphicCollection gcs = LoadRoutes( source.rte );
gcs.ForEach<Graphic>( g => graphics.Add(g) );
}
if( source.trk != null )
{
GraphicCollection gcs = LoadTracks( source.trk );
gcs.ForEach<Graphic>( g => graphics.Add( g ) );
}
return graphics;
}
//***************************************************************************************************
// Gpx
//***************************************************************************************************
private void SetGpx(String strFileName)
{
try
{
gpxType gpx = gmap.Manager.DeserializeGPX(File.ReadAllText(strFileName));
if (gpx != null)
{
if (gpx.trk.Length > 0)
{
gmap.Overlays[0].Routes[0].Points.Clear();
foreach (var trk in gpx.trk)
{
List <PointLatLng> points = new List <PointLatLng>();
foreach (var seg in trk.trkseg)
{
foreach (var p in seg.trkpt)
{
points.Add(new PointLatLng((double)p.lat, (double)p.lon));
}
}
gmap.Overlays[0].Routes[0].Points.AddRange(points);
}
tsslGpx.Text = Path.GetFileName(strFileName);
gmap.Overlays[0].Routes[0].IsVisible = true;
// gmap.ZoomAndCenterRoutes(null);
okGpx = true;
gpxFileName = strFileName;
}
}
}
catch
{
}
}
/// <summary>
/// Saves places to a file in GPX format, given pathname
/// </summary>
/// <param name="strGpxPath">The file (with full path) to save to</param>
public void SaveToGpx(string strGpxPath)
{
gpxType gpx = new gpxType();
gpx.creator = "NASA World Wind";
gpx.version = "1.1";
gpx.wpt = new wptType [this.Items.Count];
int i = 0;
foreach (ListViewItem lvi in this.Items)
{
PlaceItem pi = (PlaceItem)lvi.Tag;
wptType wp = new wptType();
wp.name = pi.pn.Name;
wp.lat = (decimal)pi.pn.Lat;
wp.lon = (decimal)pi.pn.Lon;
wp.sym = "Waypoint";
gpx.wpt[i++] = wp;
}
XmlSerializer ser = new XmlSerializer(typeof(gpxType));
TextWriter tw = new StreamWriter(strGpxPath);
ser.Serialize(tw, gpx);
tw.Close();
}
protected string SerializeToHereFormat(RouteDataDTO route)
{
var gpx = new gpxType();
gpx.trk = new trkType[1];
var trk = gpx.trk[0] = new trkType();
trk.trkseg = new trksegType[1];
var seg = trk.trkseg[0] = new trksegType();
seg.trkpt = route.Points.Select(x => new wptType()
{
lat = x.latitude,
lon = x.longitude
}).ToArray();
XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add("", "");
var serializer = new XmlSerializer(gpx.GetType());
using (StringWriter textWriter = new StringWriter())
using (XmlWriter writer = XmlWriter.Create(textWriter, new XmlWriterSettings {
OmitXmlDeclaration = true
}))
{
serializer.Serialize(writer, gpx);
var str = textWriter.ToString();
var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(str);
return(System.Convert.ToBase64String(plainTextBytes));
}
}
public void ToDataContainer_NoData_ShouldReturnEmptyDataContainer()
{
var gpx = new gpxType();
var dataContainer = _converter.ToDataContainer(gpx);
Assert.AreEqual(0, dataContainer.routes.Count);
}
static public gpxType Deserialize(string fileDirectory)
{
string fileContent = File.ReadAllText(fileDirectory);
XmlSerializer x = new XmlSerializer(typeof(gpxType));
gpxType myTest = (gpxType)x.Deserialize(new StringReader(fileContent));
return(myTest);
}
private GpxFile ReadToDto(gpxType data)
{
var dto = new GpxFile();
_mapper.Map <gpxType, GpxFile>(data, dto);
return(dto);
}
private string GetHighwayType(gpxType gpx)
{
var waypointsGroups = new List <wptType[]>();
waypointsGroups.AddRange((gpx.rte ?? new rteType[0]).Select(route => route.rtept).Where(ps => ps.All(p => p.timeSpecified)).ToArray());
waypointsGroups.AddRange((gpx.trk ?? new trkType[0]).Where(t => t.trkseg != null).Select(track => track.trkseg.SelectMany(s => s.trkpt).ToArray()).Where(ps => ps.All(p => p.timeSpecified)));
return(GetHighwayTypeFromWaypoints(waypointsGroups));
}
public void ToDataContainer_NoData_ShouldReturnEmptyDataContainer()
{
var gpx = new gpxType();
var dataContainer = _converter.ToDataContainer(gpx);
Assert.AreEqual(0, dataContainer.routes.Count);
}
// load gpx file
private void button16_Click(object sender, EventArgs e)
{
using (FileDialog dlg = new OpenFileDialog())
{
dlg.CheckPathExists = true;
dlg.CheckFileExists = false;
dlg.AddExtension = true;
dlg.DefaultExt = "gpx";
dlg.ValidateNames = true;
dlg.Title = "GMap.NET: open gpx log";
dlg.Filter = "gpx files (*.gpx)|*.gpx";
dlg.FilterIndex = 1;
dlg.RestoreDirectory = true;
if (dlg.ShowDialog() == DialogResult.OK)
{
try
{
string gpx = File.ReadAllText(dlg.FileName);
gpxType r = MainMap.Manager.DeserializeGPX(gpx);
if (r != null)
{
if (r.trk.Length > 0)
{
foreach (var trk in r.trk)
{
List <PointLatLng> points = new List <PointLatLng>();
foreach (var seg in trk.trkseg)
{
foreach (var p in seg.trkpt)
{
points.Add(new PointLatLng((double)p.lat, (double)p.lon));
}
}
GMapRoute rt = new GMapRoute(points, string.Empty);
{
rt.Stroke = new Pen(Color.FromArgb(144, Color.Red));
rt.Stroke.Width = 5;
rt.Stroke.DashStyle = System.Drawing.Drawing2D.DashStyle.DashDot;
}
routes.Routes.Add(rt);
}
MainMap.ZoomAndCenterRoutes(null);
}
}
}
catch (Exception ex)
{
// Debug.WriteLine("GPX import: " + ex.ToString());
MessageBox.Show("Error importing gpx: " + ex.Message, "GMap.NET", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
}
}
/// <summary>
/// Converts <see cref="gpxType"/> to <see cref="byte"/> array
/// </summary>
/// <param name="gpx">The <see cref="gpxType"/></param>
/// <returns>The <see cref="byte"/> array</returns>
public static byte[] ToBytes(this gpxType gpx)
{
using (var outputStream = new MemoryStream())
{
var xmlSerializer = new XmlSerializer(typeof(gpxType));
xmlSerializer.Serialize(outputStream, gpx);
return(outputStream.ToArray());
}
}
public void ToDataContainer_RouteWithoutPoints_ShouldReturnRouteWithoutPointsDataContainer()
{
var gpx = new gpxType
{
trk = new[] { new trkType() }
};
var dataContainer = _converter.ToDataContainer(gpx);
Assert.AreEqual(0, dataContainer.routes.Count);
}
public void ConvertGpxToDataContainer_NonSiteFileWithTwoSegmenets_ShouldManipulateRouteData()
{
var gpxToConvert = new gpxType
{
trk = new[]
{
new trkType
{
trkseg = new[]
{
new trksegType
{
trkpt = new[]
{
new wptType {
lat = 1, lon = 2
},
new wptType {
lat = 3, lon = 4
}
}
},
new trksegType
{
trkpt = new[]
{
new wptType {
lat = 5, lon = 6
},
new wptType {
lat = 7, lon = 8
}
}
}
}
}
}
};
var newRouteData = new RouteData
{
segments = new List <RouteSegmentData>
{
new RouteSegmentData(),
new RouteSegmentData(),
new RouteSegmentData(),
new RouteSegmentData()
}
};
_routeDataSplitterService.Split(Arg.Any <RouteData>(), Arg.Any <string>()).Returns(newRouteData);
var dataContainer = _converterService.ToDataContainer(gpxToConvert.ToBytes(), FlowFormats.GPX).Result;
Assert.AreEqual(1, dataContainer.routes.Count);
Assert.AreEqual(newRouteData.segments.Count, dataContainer.routes.First().segments.Count);
}
public void CovertTwoWays_OnlyOneTrack_ShouldBeTheSame()
{
gpxType gpx = new gpxType
{
trk = new[]
{
new trkType
{
name = "tarck",
trkseg = new[]
{
new trksegType
{
trkpt = new[]
{
new wptType {
lat = 1, lon = 2, ele = 3, eleSpecified = true
},
new wptType {
lat = 4, lon = 5, ele = 6, eleSpecified = true
}
}
},
new trksegType
{
trkpt = new[]
{
new wptType {
lat = 4, lon = 5, ele = 6, eleSpecified = true
},
new wptType {
lat = 14, lon = 15
}
}
}
}
}
}
};
var featureCollection = _gpxGeoJsonConverter.ToGeoJson(gpx);
var newGpx = _gpxGeoJsonConverter.ToGpx(featureCollection);
Assert.AreEqual(gpx.trk.Length, newGpx.trk.Length);
Assert.AreEqual(gpx.trk[0].name, newGpx.trk[0].name);
for (int i = 0; i < newGpx.trk[0].trkseg.Length; i++)
{
for (int j = 0; j < newGpx.trk[0].trkseg[i].trkpt.Length; j++)
{
Assert.AreEqual(gpx.trk[0].trkseg[i].trkpt[j].ele, newGpx.trk[0].trkseg[i].trkpt[j].ele);
Assert.AreEqual(gpx.trk[0].trkseg[i].trkpt[j].lat, newGpx.trk[0].trkseg[i].trkpt[j].lat);
Assert.AreEqual(gpx.trk[0].trkseg[i].trkpt[j].lon, newGpx.trk[0].trkseg[i].trkpt[j].lon);
}
}
}
public void ToDataContainer_RouteWithoutPoints_ShouldReturnRouteWithoutPointsDataContainer()
{
var gpx = new gpxType
{
trk = new[] { new trkType() }
};
var dataContainer = _converter.ToDataContainer(gpx);
Assert.AreEqual(0, dataContainer.routes.Count);
}
/// <summary>
/// Converts <see cref="gpxType"/> to <see cref="byte"/> array
/// </summary>
/// <param name="gpx">The <see cref="gpxType"/></param>
/// <returns>The <see cref="byte"/> array</returns>
public static byte[] ToBytes(this gpxType gpx)
{
using (var outputStream = new MemoryStream())
{
var xmlSerializer = new XmlSerializer(typeof(gpxType));
var streamWriter = new StreamWriter(outputStream, System.Text.Encoding.UTF8);
xmlSerializer.Serialize(streamWriter, gpx);
return(outputStream.ToArray());
}
}
public void TestInitialize()
{
_randomBytes = new byte[] { 0, 1, 1, 0 };
_simpleGpx = new gpxType {
wpt = new[] { new wptType() }
};
_gpsBabelGateway = Substitute.For <IGpsBabelGateway>();
_routeDataSplitterService = Substitute.For <IRouteDataSplitterService>();
_converterService = new DataContainerConverterService(_gpsBabelGateway, new GpxGeoJsonConverter(), new GpxDataContainerConverter(), _routeDataSplitterService);
}
static public void Serialize(gpxType gpx, string outFile)
{
XmlSerializer serializer = new XmlSerializer(typeof(gpxType));
//using (TextWriter writer = new StreamWriter(@"C:\Xml.xml"))
using (TextWriter writer = new StreamWriter(outFile))
{
serializer.Serialize(writer, gpx);
}
}
public async Task SaveToFile(string collection)
{
var invalids = System.IO.Path.GetInvalidFileNameChars();
var filename = string.Join("_", Name.Split(invalids, StringSplitOptions.RemoveEmptyEntries)).TrimEnd('.') + ".gpx";
var serializer = new XmlSerializer(typeof(gpxType));
StorageFolder FavoritesFolder = await ApplicationData.Current.RoamingFolder.CreateFolderAsync("Favorites", CreationCollisionOption.OpenIfExists);
if (collection != "")
{
FavoritesFolder = await FavoritesFolder.CreateFolderAsync(collection, CreationCollisionOption.OpenIfExists);
}
StorageFile file = await FavoritesFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
Stream stream = await file.OpenStreamForWriteAsync();
using (stream)
{
gpxType objectToSave = new gpxType()
{
metadata = new metadataType()
{
name = Name,
desc = Description,
extensions = new extensionsType()
{
symbol = Symbol,
address = Address
},
author = new personType()
{
name = "Cyke Maps"
},
timeSpecified = true,
time = Timestamp
},
creator = "Cyke Maps",
wpt = new wptType[]
{
new wptType()
{
lat = (decimal)Location.Position.Latitude,
lon = (decimal)Location.Position.Longitude,
eleSpecified = true,
ele = (decimal)Location.Position.Altitude
}
}
};
serializer.Serialize(stream, objectToSave);
}
// Reload the Favorites
LibraryManager.Current.Reload(ReloadParameter.Favorites);
}
private List <ILineString> GpxToItmLineStrings(gpxType gpx)
{
return((gpx.rte ?? new rteType[0])
.Select(route => ToItmLineString(route.rtept))
.Concat((gpx.trk ?? new trkType[0])
.Select(track => (track.trkseg ?? new trksegType[0])
.SelectMany(s => s.trkpt))
.Select(ToItmLineString))
.Where(l => l.Coordinates.Any())
.ToList());
}
public void PostGpsTrace_FileProvidedForFootwayGpxFile_ShouldReturnFeatureCollection()
{
var gpx = new gpxType
{
rte = new[]
{
new rteType
{
rtept = new[]
{
new wptType {lat = 0, lon = 0, timeSpecified = false, time = DateTime.Now},
new wptType {lat = 0.00001M, lon = 0.00001M, timeSpecified = true, time = DateTime.Now.AddMinutes(1)},
}
}
},
trk = new[]
{
new trkType
{
trkseg = new[]
{
new trksegType
{
trkpt = new[]
{
new wptType {lat = 0.00002M, lon = 0.00002M, timeSpecified = true, time = DateTime.Now.AddMinutes(2)},
new wptType {lat = 0.00003M, lon = 0.00003M, timeSpecified = true, time = DateTime.Now.AddMinutes(3)}
}
}
}
}
}
};
var fetcher = Substitute.For<IRemoteFileFetcherGateway>();
var file = Substitute.For<IFormFile>();
file.FileName.Returns("SomeFile.gpx");
_dataContainerConverterService.Convert(Arg.Any<byte[]>(), Arg.Any<string>(), Arg.Any<string>()).Returns(gpx.ToBytes());
_httpGatewayFactory.CreateRemoteFileFetcherGateway(Arg.Any<TokenAndSecret>()).Returns(fetcher);
_addibleGpxLinesFinderService.GetLines(Arg.Any<List<ILineString>>()).Returns(
new List<LineString>
{
new LineString(new[] {new Coordinate(0, 0), new Coordinate(1, 1)})
}.AsEnumerable()
);
_controller.SetupIdentity();
var results = _controller.PostGpsTrace(null, file).Result as OkObjectResult;
Assert.IsNotNull(results);
var featureCollection = results.Value as FeatureCollection;
Assert.IsNotNull(featureCollection);
Assert.AreEqual(1, featureCollection.Features.Count);
Assert.IsTrue(featureCollection.Features.First().Attributes.GetValues().Contains("footway"));
}
// http://www.independent-software.com/gmap-net-beginners-tutorial-maps-markers-polygons-routes-updated-for-vs2015-and-gmap1-7.html
// http://presentation427.rssing.com/chan-4175058/all_p70.html
private void LoadGpxFile(String filename)
{
try
{
string gpx = File.ReadAllText(filename);
gpxType r = gmap.Manager.DeserializeGPX(gpx);
if (r != null)
{
if (r.trk.Length > 0)
{
foreach (var trk in r.trk)
{
List <PointLatLng> points = new List <PointLatLng>();
foreach (var seg in trk.trkseg)
{
foreach (var p in seg.trkpt)
{
points.Add(new PointLatLng((double)p.lat, (double)p.lon));
}
}
GMapRoute rt = new GMapRoute(points, string.Empty);
{
rt.Stroke.MiterLimit = 0;
rt.Stroke = new Pen(Color.FromArgb(255, Color.Red));
rt.Stroke.Width = 3;
rt.Stroke.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
}
mainOverlay.Routes.Add(rt);
}
// gmap.ZoomAndCenterRoutes(null);
// add
gmap.Overlays.Add(mainOverlay);
log += Environment.NewLine + Path.GetFileName(filename) + " loaded successfully";
f.logtext.Text = log;
f.logtext.Refresh();
}
}
}
catch (Exception ex)
{
log += Environment.NewLine + Path.GetFileName(filename) + " error (" + ex.ToString() + ")";
f.logtext.Text = log;
f.logtext.Refresh();
//Debug.WriteLine("GPX import: " + ex.ToString());
//MessageBox.Show("Error importing gpx: " + ex.Message, "GMap.NET", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public void ConvertGpxToDataContainer_NonSiteFileNoPointsInTrack_ShouldManipulateRouteData()
{
var gpxToConvert = new gpxType {
rte = new[] { new rteType {
rtept = new wptType[0]
} }
};
var dataContainer = _converterService.ToDataContainer(gpxToConvert.ToBytes(), FlowFormats.GPX).Result;
Assert.AreEqual(0, dataContainer.routes.Count);
}
public void ToDataContainer_PointsOlny_ShouldReturnRouteWithoutPointsOnlyDataContainer()
{
var gpx = new gpxType
{
wpt = new[] { new wptType {
lat = 4, lon = 5, ele = 6, eleSpecified = true
} },
};
var dataContainer = _converter.ToDataContainer(gpx);
Assert.AreEqual(1, dataContainer.routes.Count);
Assert.AreEqual(0, dataContainer.routes.First().segments.Count);
Assert.AreEqual(1, dataContainer.routes.First().markers.Count);
}
public DataContainer ToDataContainer(gpxType gpx)
{
gpx.UpdateBounds();
var container = new DataContainer
{
markers = (gpx.wpt ?? new wptType[0]).Select(ToMarkerData).ToList(),
routes = ConvertRoutesToRoutesData(gpx.rte ?? new rteType[0])
};
container.routes.AddRange(ConvertTracksToRouteData(gpx.trk ?? new trkType[0]));
if (gpx.metadata?.bounds != null)
{
UpdateBoundingBox(container, gpx.metadata.bounds);
}
return container;
}
private void compileMultiGpx(string path)
{
List <string> directories = Directory.GetDirectories(path).ToList();
List <gpxType> tracesGPX = new List <gpxType>();
List <trksegType> listSegments = new List <trksegType>();
foreach (string dir in directories)
{
List <string> files = Directory.GetFiles(dir, "*.gpx").ToList();
foreach (string file in files)
{
tracesGPX.Add(Helpers.tools.Deserialize(file));
}
}
foreach (gpxType trace in tracesGPX)
{
if (trace.trk == null || trace.trk.Length == 0)
{
break;
}
List <trkType> trkTypes = trace.trk.ToList();
foreach (trkType trkType in trkTypes)
{
if (trkType.trkseg == null || trkType.trkseg.Length == 0)
{
break;
}
foreach (trksegType t in trkType.trkseg.ToList())
{
listSegments.Add(t);
}
}
}
gpxType gpxOut = new gpxType();
gpxOut.creator = "Nicolas PERDU";
gpxOut.trk = new trkType[1] {
new trkType()
};
gpxOut.trk[0].desc = "Complile multi files";
gpxOut.trk[0].trkseg = listSegments.ToArray();
Helpers.tools.Serialize(gpxOut, path + Path.DirectorySeparatorChar + "compile multi gpx.gpx");
}
public void CovertTwoWays_OnlyOnePoint_ShouldBeTheSame()
{
gpxType gpx = new gpxType
{
wpt = new[] { new wptType { lat = 1, lon = 2, ele = 3, eleSpecified = true, name = "point" } }
};
var featureCollection = _gpxGeoJsonConverter.ToGeoJson(gpx);
var newGpx = _gpxGeoJsonConverter.ToGpx(featureCollection);
Assert.AreEqual(gpx.wpt.Length, newGpx.wpt.Length);
Assert.AreEqual(gpx.wpt[0].name, newGpx.wpt[0].name);
Assert.AreEqual(gpx.wpt[0].ele, newGpx.wpt[0].ele);
Assert.AreEqual(gpx.wpt[0].lat, newGpx.wpt[0].lat);
Assert.AreEqual(gpx.wpt[0].lon, newGpx.wpt[0].lon);
}
public byte[] Transform(byte[] content)
{
var gpx = content.ToGpx();
var singleTrackGpx = new gpxType
{
wpt = gpx.wpt,
rte = new rteType[0],
trk = (gpx.trk ?? new trkType[0]).Select(t => new trkType
{
name = t.name,
desc = t.desc,
cmt = t.cmt,
trkseg = new[] { new trksegType { trkpt = (t.trkseg ?? new trksegType[0]).SelectMany(s => s.trkpt).ToArray() } }
}).ToArray()
};
return singleTrackGpx.ToBytes();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="filename"></param>
public GPX11File(string filename)
{
try
{
_filename = filename;
_gpx11 = DeserializeGPX();
_gpxFileDetails = new GPX11FileDetails(_gpx11);
_routes = GetRoutes();
_tracks = GetTracks();
_waypoints = GetWayPoints();
}
catch (Exception)
{
_isFileValid = false;
}
}
public void ConvertGpxVersion1ToDataContainer_NonSiteFileNoPointsInTrack_ShouldManipulateRouteData()
{
string gpxVersion1 = "<?xml version='1.0' encoding='UTF-8'?><gpx version='1.0' creator='GPSBabel - http://www.gpsbabel.org' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://www.topografix.com/GPX/1/0' xsi:schemaLocation='http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd'><rte><rtept lat='33.1187173918366' lon='35.6488631636844'><ele>0.000000</ele><name>A001</name><cmt>60963[1] דרך עפר היוצאת מעיקול בכביש 959 - נקודת ההתחלה</cmt><desc>60963[1] דרך עפר היוצאת מעיקול בכביש 959 - נקודת ההתחלה</desc></rtept></rte></gpx>";
byte[] bytes = Encoding.UTF8.GetBytes(gpxVersion1);
var gpx = new gpxType {
rte = new[] { new rteType {
rtept = new wptType[0]
} }
};
_gpsBabelGateway.ConvertFileFromat(bytes, Arg.Any <string>(), Arg.Any <string>()).Returns(gpx.ToBytes());
var dataContainer = _converterService.ToDataContainer(bytes, FlowFormats.GPX).Result;
Assert.AreEqual(0, dataContainer.routes.Count);
}
public void CovertGeoJsonToGpx_OnlyOnePoint_ShouldBeConverted()
{
gpxType gpx = new gpxType
{
wpt = new[] {new wptType {lat = 1, lon = 2, ele = 3, eleSpecified = false, name = "point"}}
};
var featureCollection = _gpxGeoJsonConverter. ToGeoJson(gpx);
Assert.AreEqual(1, featureCollection.Features.Count);
var point = featureCollection.Features.Select(f => f.Geometry).OfType<Point>().FirstOrDefault();
Assert.IsNotNull(point);
var coordinates = point.Coordinate;
Assert.IsNotNull(coordinates);
Assert.AreEqual(gpx.wpt[0].name, featureCollection.Features.First().Attributes["name"]);
Assert.IsTrue(double.IsNaN(coordinates.Z));
Assert.AreEqual(gpx.wpt[0].lat, (decimal)coordinates.Y);
Assert.AreEqual(gpx.wpt[0].lon, (decimal)coordinates.X);
}
public static gpxType ReadGPX( XElement element )
{
element.RequireArgument<XElement>( "element" ).NotNull<XElement>();
if( element.Name.LocalName != "gpx" )
throw new FormatException( string.Format("An element named 'gpx' was expected. But the element found was {0}.", element.Name) );
gpxType gpx = new gpxType();
XNamespace ns = element.Name.Namespace;
gpx.version = element.Attribute( "version" ).Value;
if(element.Element(ns + "metadata") != null)
gpx.metadata = ReadMetadata( element.Element( ns + "metadata" ) );
if(element.Elements(ns + "wpt") != null)
gpx.wpt = ReadWayPoints( element.Elements( ns + "wpt" ) );
if(element.Elements( ns + "rte") != null)
gpx.rte = ReadRoutes( element.Elements( ns + "rte" ) );
if(element.Elements( ns + "trk") != null)
gpx.trk = ReadTracks( element.Elements( ns + "trk" ) );
//The extensions cannot be read because they are custom elements and can be in any format preferred
return gpx;
}
public GPXLayer()
{
Renderer = new SimpleRenderer();
_completeHandler = ( stm ) =>
{
Graphics.Clear();
_source = GPXReader.ReadGPX( stm );
Graphics = LoadGraphics(_source);
if( LoadCompleted != null )
{
LoadCompleted( this, new EventArgs() );
}
};
_errorHandler = ( ex ) =>
{
if( LoadFailed != null )
{
LoadFailed( this, new EventArgs<string>(ex.Message) );
}
};
}
public void CovertTwoWays_OnlyOneRoute_ShouldBeTheSame()
{
gpxType gpx = new gpxType
{
rte = new [] { new rteType { name = "route", rtept = new[]
{
new wptType { lat = 1, lon = 2, ele = 3, eleSpecified = true },
new wptType { lat = 4, lon = 5 }
} } },
};
var featureCollection = _gpxGeoJsonConverter.ToGeoJson(gpx);
var newGpx = _gpxGeoJsonConverter.ToGpx(featureCollection);
Assert.AreEqual(gpx.rte.Length, newGpx.rte.Length);
Assert.AreEqual(gpx.rte[0].name, newGpx.rte[0].name);
for (int i = 0; i < newGpx.rte[0].rtept.Length; i++)
{
Assert.AreEqual(gpx.rte[0].rtept[i].ele, newGpx.rte[0].rtept[i].ele);
Assert.AreEqual(gpx.rte[0].rtept[i].lat, newGpx.rte[0].rtept[i].lat);
Assert.AreEqual(gpx.rte[0].rtept[i].lon, newGpx.rte[0].rtept[i].lon);
}
}
public void ToDataContainer_TrackOlnyWithSinglePoint_ShouldReturnRouteDataContainer()
{
var gpx = new gpxType
{
trk = new[] { new trkType { trkseg = new[] { new trksegType { trkpt = new[] { new wptType { lat = 1, lon = 2 }, new wptType { lat = 3, lon = 4 } } } } } }
};
var dataContainer = _converter.ToDataContainer(gpx);
Assert.AreEqual(1, dataContainer.routes.Count);
Assert.AreEqual(0, dataContainer.markers.Count);
Assert.AreEqual(1, dataContainer.routes.First().segments.Count);
}
public void CovertTwoWays_OnlyOneTrackWithOneSegment_ShouldBeTheSame()
{
gpxType gpx = new gpxType
{
trk = new[]
{
new trkType
{
name = "tarck",
trkseg = new[]
{
new trksegType
{
trkpt = new[]
{
new wptType {lat = 1, lon = 2, ele = 3, eleSpecified = true},
new wptType {lat = 4, lon = 5, ele = 6, eleSpecified = true}
}
},
}
}
}
};
var featureCollection = _gpxGeoJsonConverter.ToGeoJson(gpx);
Assert.AreEqual(1, featureCollection.Features.Count);
var lineString = featureCollection.Features.First().Geometry as LineString;
Assert.IsNotNull(lineString);
Assert.AreEqual(2, lineString.Coordinates.Length);
}
public async Task SaveToFile(string collection)
{
var invalids = System.IO.Path.GetInvalidFileNameChars();
var filename = string.Join("_", Name.Split(invalids, StringSplitOptions.RemoveEmptyEntries)).TrimEnd('.') + ".gpx";
var serializer = new XmlSerializer(typeof(gpxType));
StorageFolder FavoritesFolder = await ApplicationData.Current.RoamingFolder.CreateFolderAsync("Routes", CreationCollisionOption.OpenIfExists);
if (collection != "") FavoritesFolder = await FavoritesFolder.CreateFolderAsync(collection, CreationCollisionOption.OpenIfExists);
StorageFile file = await FavoritesFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
Stream stream = await file.OpenStreamForWriteAsync();
using (stream)
{
gpxType objectToSave = new gpxType()
{
metadata = new metadataType()
{
name = Name,
desc = Description,
extensions = new extensionsType()
{
symbol = Symbol // TODO: Add distance, uphill, downhill and so on
},
author = new personType()
{
name = "Cyke Maps"
},
timeSpecified = true,
time = Timestamp
},
creator = "Cyke Maps",
wpt = new wptType[]
{
new wptType()
{
name = "StartPoint",
lat = (decimal)StartPoint.Location.Position.Latitude,
lon = (decimal)StartPoint.Location.Position.Longitude,
eleSpecified = true,
ele = (decimal)StartPoint.Location.Position.Altitude
}
},
trk = new trkType[] // Add a gpx track with the Track from the route
{
new trkType()
{
trkseg = new trksegType[] {
new trksegType()
{
trkpt = Track.Select(pos => new wptType() // Convert the Track from the route to a wptType[] Array
{
lat = (decimal)pos.Latitude,
lon = (decimal)pos.Longitude,
ele = (decimal)pos.Altitude,
eleSpecified = true
}).ToArray()
}
}
}
}
};
serializer.Serialize(stream, objectToSave);
}
// Reload the Favorites
LibraryManager.Current.Reload(ReloadParameter.Routes);
}
/// <summary>
/// Saves places to a file in GPX format, given pathname
/// </summary>
/// <param name="strGpxPath">The file (with full path) to save to</param>
public void SaveToGpx(string strGpxPath)
{
gpxType gpx = new gpxType();
gpx.creator = "NASA World Wind";
gpx.version = "1.1";
gpx.wpt = new wptType [this.Items.Count];
int i = 0;
foreach(ListViewItem lvi in this.Items)
{
PlaceItem pi = (PlaceItem)lvi.Tag;
wptType wp = new wptType();
wp.name = pi.pn.Name;
wp.lat = (decimal)pi.pn.Lat;
wp.lon = (decimal)pi.pn.Lon;
wp.sym = "Waypoint";
gpx.wpt[i++] = wp;
}
XmlSerializer ser = new XmlSerializer(typeof(gpxType));
TextWriter tw = new StreamWriter(strGpxPath);
ser.Serialize(tw, gpx);
tw.Close();
}
public void ConvertGpxVersion1ToDataContainer_NonSiteFileNoPointsInTrack_ShouldManipulateRouteData()
{
string gpxVersion1 = "<?xml version='1.0' encoding='UTF-8'?><gpx version='1.0' creator='GPSBabel - http://www.gpsbabel.org' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://www.topografix.com/GPX/1/0' xsi:schemaLocation='http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd'><rte><rtept lat='33.1187173918366' lon='35.6488631636844'><ele>0.000000</ele><name>A001</name><cmt>60963[1] דרך עפר היוצאת מעיקול בכביש 959 - נקודת ההתחלה</cmt><desc>60963[1] דרך עפר היוצאת מעיקול בכביש 959 - נקודת ההתחלה</desc></rtept></rte></gpx>";
byte[] bytes = Encoding.UTF8.GetBytes(gpxVersion1);
var gpx = new gpxType { rte = new[] { new rteType { rtept = new wptType[0] } } };
_gpsBabelGateway.ConvertFileFromat(bytes, Arg.Any<string>(), Arg.Any<string>()).Returns(Task.FromResult(gpx.ToBytes()));
var dataContainer = _converterService.ToDataContainer(bytes, "gpx").Result;
Assert.AreEqual(0, dataContainer.routes.Count);
}
private string GetRoutingType(gpxType gpx)
{
var waypointsGroups = new List<wptType[]>();
waypointsGroups.AddRange((gpx.rte ?? new rteType[0]).Select(route => route.rtept).Where(ps => ps.All(p => p.timeSpecified)).ToArray());
waypointsGroups.AddRange((gpx.trk ?? new trkType[0]).Select(track => track.trkseg.SelectMany(s => s.trkpt).ToArray()).Where(ps => ps.All(p => p.timeSpecified)));
return GetRoutingType(waypointsGroups);
}
private void LoadGraphics(gpxType source, GraphicCollection graphics)
{
if( source == null )
return;
if( source.wpt != null )
LoadWayPoints( source.wpt, graphics );
if( source.rte != null )
LoadRoutes( source.rte, graphics );
if( source.trk != null )
LoadTracks( source.trk, graphics );
}
private GraphicCollection LoadGraphics( gpxType source )
{
GraphicCollection gcs = GPXHelper.LoadGraphics( source );
foreach( Graphic gr in gcs )
{
gr.Symbol = Renderer.GetSymbol( gr );
}
return gcs;
}
public void CovertTwoWays_OnlyOneTrack_ShouldBeTheSame()
{
gpxType gpx = new gpxType
{
trk = new[]
{
new trkType
{
name = "tarck",
trkseg = new[]
{
new trksegType
{
trkpt = new[]
{
new wptType {lat = 1, lon = 2, ele = 3, eleSpecified = true},
new wptType {lat = 4, lon = 5, ele = 6, eleSpecified = true}
}
},
new trksegType
{
trkpt = new[]
{
new wptType {lat = 4, lon = 5, ele = 6, eleSpecified = true},
new wptType {lat = 14, lon = 15}
}
}
}
}
}
};
var featureCollection = _gpxGeoJsonConverter.ToGeoJson(gpx);
var newGpx = _gpxGeoJsonConverter.ToGpx(featureCollection);
Assert.AreEqual(gpx.trk.Length, newGpx.trk.Length);
Assert.AreEqual(gpx.trk[0].name, newGpx.trk[0].name);
for (int i = 0; i < newGpx.trk[0].trkseg.Length; i++)
{
for (int j = 0; j < newGpx.trk[0].trkseg[i].trkpt.Length; j++)
{
Assert.AreEqual(gpx.trk[0].trkseg[i].trkpt[j].ele, newGpx.trk[0].trkseg[i].trkpt[j].ele);
Assert.AreEqual(gpx.trk[0].trkseg[i].trkpt[j].lat, newGpx.trk[0].trkseg[i].trkpt[j].lat);
Assert.AreEqual(gpx.trk[0].trkseg[i].trkpt[j].lon, newGpx.trk[0].trkseg[i].trkpt[j].lon);
}
}
}
public async Task SaveToFile(string collection)
{
var invalids = System.IO.Path.GetInvalidFileNameChars();
var filename = string.Join("_", Name.Split(invalids, StringSplitOptions.RemoveEmptyEntries)).TrimEnd('.') + ".gpx";
var serializer = new XmlSerializer(typeof(gpxType));
StorageFolder FavoritesFolder = await ApplicationData.Current.RoamingFolder.CreateFolderAsync("Favorites", CreationCollisionOption.OpenIfExists);
if (collection != "") FavoritesFolder = await FavoritesFolder.CreateFolderAsync(collection, CreationCollisionOption.OpenIfExists);
StorageFile file = await FavoritesFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
Stream stream = await file.OpenStreamForWriteAsync();
using (stream)
{
gpxType objectToSave = new gpxType()
{
metadata = new metadataType()
{
name = Name,
desc = Description,
extensions = new extensionsType()
{
symbol = Symbol,
address = Address
},
author = new personType()
{
name = "Cyke Maps"
},
timeSpecified = true,
time = Timestamp
},
creator = "Cyke Maps",
wpt = new wptType[]
{
new wptType()
{
lat = (decimal)Location.Position.Latitude,
lon = (decimal)Location.Position.Longitude,
eleSpecified = true,
ele = (decimal)Location.Position.Altitude
}
}
};
serializer.Serialize(stream, objectToSave);
}
// Reload the Favorites
LibraryManager.Current.Reload(ReloadParameter.Favorites);
}
public void ConvertGpxToDataContainer_NonSiteFile_ShouldManipulateRouteData()
{
var gpxToConvert = new gpxType
{
trk = new[] { new trkType {
trkseg = new[]
{
new trksegType
{
trkpt = new[]
{
new wptType {lat = 1, lon = 2},
new wptType {lat = 3, lon = 4}
}
},
new trksegType
{
trkpt = new[]
{
new wptType {lat = 5, lon = 6},
new wptType {lat = 7, lon = 8}
}
}
}
}}
};
var dataContainer = _converterService.ToDataContainer(gpxToConvert.ToBytes(), "gpx").Result;
Assert.AreEqual(1, dataContainer.routes.Count);
Assert.AreEqual(4, dataContainer.routes.First().segments.Count);
}
public void ToDataContainer_PointsOlny_ShouldReturnRouteWithoutPointsOnlyDataContainer()
{
var gpx = new gpxType
{
wpt = new[] { new wptType { lat = 4, lon = 5, ele = 6, eleSpecified = true } },
};
var dataContainer = _converter.ToDataContainer(gpx);
Assert.AreEqual(0, dataContainer.routes.Count);
Assert.AreEqual(1, dataContainer.markers.Count);
}
public void ConvertGpxToDataContainer_NonSiteFileShortTrack_ShouldManipulateRouteData()
{
var gpxToConvert = new gpxType
{
trk = new[] { new trkType {
trkseg = new[]
{
new trksegType
{
trkpt = new[]
{
new wptType {lat = 1, lon = 1},
new wptType {lat = 1, lon = 1.000001M},
new wptType {lat = 1, lon = 1.000002M},
new wptType {lat = 1, lon = 1.000003M}
}
}
}
}}
};
var dataContainer = _converterService.ToDataContainer(gpxToConvert.ToBytes(), "gpx").Result;
Assert.AreEqual(1, dataContainer.routes.Count);
Assert.AreEqual(2, dataContainer.routes.First().segments.Count);
}
public void ConvertGpxToDataContainer_NonSiteFileNoPointsInTrack_ShouldManipulateRouteData()
{
var gpxToConvert = new gpxType { rte = new[] { new rteType { rtept = new wptType[0] } } };
var dataContainer = _converterService.ToDataContainer(gpxToConvert.ToBytes(), "gpx").Result;
Assert.AreEqual(0, dataContainer.routes.Count);
}
public void ToDataContainer_RouteWithPoints_ShouldReturnRouteWithPointsDataContainer()
{
var gpx = new gpxType
{
wpt = new [] { new wptType { lat = 4, lon = 5, ele = 6, eleSpecified = true} },
rte = new[] { new rteType { rtept = new [] { new wptType { lat = 1, lon = 2, ele = 3, eleSpecified = true} } } }
};
var dataContainer = _converter.ToDataContainer(gpx);
Assert.AreEqual(1, dataContainer.routes.Count);
Assert.AreEqual(1, dataContainer.markers.Count);
}
private List<LineString> GpxToLineStrings(gpxType gpx)
{
var lineStings = (gpx.rte ?? new rteType[0])
.Select(route => ToItmLineString(route.rtept)).ToList();
var tracksPointsList = (gpx.trk ?? new trkType[0])
.Select(track => track.trkseg.SelectMany(s => s.trkpt).ToArray())
.Select(ToItmLineString);
lineStings.AddRange(tracksPointsList);
return lineStings;
}
