public void ReadFiletoWayPointStructure()
{
var fileReader = new GpxFileReader(FilePath, XmlNamespace);
var result = fileReader.ReadWayPoints().ToArray();
Assert.NotEmpty(result);
}
public Analizer(string filePath, string xmlNameSpace)
{
_distanceAnalizerFactory = new DistanceAnalizerFactory();
IFileReader fileReader = new GpxFileReader(filePath, xmlNameSpace);
_wayPoints = fileReader.ReadWayPoints().ToArray();
}
/// <summary>
/// Prepares a single track edit from all of the data in a given file
/// </summary>
public TrackEditData PreviewTrack(string uri)
{
// load file and read data
var file = new FileInfo(uri);
var read = new GpxFileReader(file.FullName);
var data = read.ReadFile();
// create new extract entity
var track = new TrackEditData();
track.Key = Graffiti.Crypto.GetNewHash();
track.Source = file.FullName;
// set default name value
track.Name = data.Name;
if (String.IsNullOrWhiteSpace(track.Name))
{
track.Name = Path.GetFileNameWithoutExtension(file.Name);
}
// prepare points and source points lists
track.DataPoints = data.Tracks.SelectMany(x => x.PointData).ToList();
track.Points = track.DataPoints.ToList <IGpxPoint>();
return(track);
}
public void GpxFileReader_Waypoints()
{
var uri = TestsHelper.GetTestDataFileUri(@"Gpx\Waypoints.gpx");
var r = new GpxFileReader(uri);
var d = r.ReadFile();
Assert.AreEqual(4, d.Waypoints.Count);
}
private GpxInformation LoadGPXData(string fileName)
{
var fileReader = new GpxFileReader();
var path = Path.Combine(UnitTestDirectory, fileName);
var gpxInfo = fileReader.LoadFile(path);
_geometryFactory = new GeometryFactory(gpxInfo);
return(gpxInfo);
}
public void GpxFileReader_Version1_1()
{
var uri = TestsHelper.GetTestDataFileUri(@"Gpx\Version1_1.gpx");
var r = new GpxFileReader(uri);
var d = r.ReadFile();
Assert.AreEqual(1, d.Tracks.Count);
Assert.AreEqual(4, d.Tracks.First().PointData.Count);
}
private GpxInformation GetGPXData(string fileName)
{
var gpxFileInformation = new GpxFileReader().LoadFile(fileName);
gpxFileInformation.Tracks.ForEach(t => t.IsConvertedToRoute = true);
var factory = new GeometryFactory(gpxFileInformation);
factory.CreateGeometries();
return(gpxFileInformation);
}
public void GpxFileReader_TrackWithoutSegments()
{
var uri = TestsHelper.GetTestDataFileUri(@"Gpx\TrackWithoutSegments.gpx");
var r = new GpxFileReader(uri);
var d = r.ReadFile();
Assert.AreEqual(1, d.Tracks.Count);
Assert.AreEqual(4, d.Tracks.First().PointData.Count);
}
public void GpxFileReader_CreatorAndVersion()
{
var uri = TestsHelper.GetTestDataFileUri(@"Gpx\Example1.gpx");
var r = new GpxFileReader(uri);
r.ReadFile();
Assert.AreEqual("GPSLogger - http://gpslogger.mendhak.com/", r.Creator);
Assert.AreEqual(Convert.ToDecimal(1.0), r.Version);
}
public void GpxFileReader_Routes()
{
var uri = TestsHelper.GetTestDataFileUri(@"Gpx\Routes.gpx");
var r = new GpxFileReader(uri);
var d = r.ReadFile();
Assert.AreEqual(2, d.Routes.Count);
Assert.AreEqual(4, d.Routes.First().PointData.Count);
Assert.AreEqual(4, d.Routes.Last().PointData.Count);
}
public void Save_And_Check_For_POIs()
{
string fileName = "65.gpx";
var path = Path.Combine(UnitTestDirectory, fileName);
var layers = GetLayers(path);
GetPOIsCount().Should().Be(4);
_vm.SaveLayerCommand.Execute(layers.Where(x => x.Type == LayerType.GPXRoute).First());
var gpxInfo = new GpxFileReader().LoadFile(path);
gpxInfo.WayPoints.Count.Should().Be(4);
}
private void Load(string uri)
{
try
{
var reader = new GpxFileReader(uri);
_data = reader.ReadFile();
}
catch (Exception ex)
{
Error = ex;
}
}
private BikeTouringGISLayer CreateLayer(string fileName)
{
var path = Path.Combine(UnitTestDirectory, fileName);
var gpxInfo = new GpxFileReader().LoadFile(path);
gpxInfo.Tracks.ForEach(x => x.IsConvertedToRoute = true);
var factory = new GeometryFactory(gpxInfo);
factory.CreateGeometries();
var layer = new BikeTouringGISLayer("testroute", gpxInfo.Routes.First());
layer.SetExtentToFitWithWaypoints(gpxInfo.WayPointsExtent);
return(layer);
}
internal async void OpenGpxFile(BikeTouringGISMapViewModel mapViewModel, string path)
{
if (_loadedFiles.Exists(x => x.Equals(path)))
{
return;
}
var gpxFileInformation = new GpxFileReader().LoadFile(path);
foreach (var track in gpxFileInformation.Tracks)
{
bool convertTrack = ConvertTracksToRoutesAutomatically;
var convertTrackDialogResult = convertTrack ? MessageDialogResult.Affirmative : MessageDialogResult.FirstAuxiliary;
if (!convertTrack)
{
StringBuilder textBuilder = new StringBuilder();
textBuilder.AppendLine($"Track {track.Name} is defined as track and not as route");
textBuilder.AppendLine();
textBuilder.AppendLine("routes are used by navigation-devices");
textBuilder.AppendLine("tracks are to register where you have been");
textBuilder.AppendLine();
textBuilder.AppendLine("Do you want to convert it to a route?");
convertTrackDialogResult = await ConvertTrackToRoute(textBuilder.ToString());
}
switch (convertTrackDialogResult)
{
case MessageDialogResult.Affirmative:
track.IsConvertedToRoute = true;
break;
case MessageDialogResult.Negative:
break;
case MessageDialogResult.FirstAuxiliary:
return;
}
}
_loadedFiles.Add(path);
var geometryFactory = new GeometryFactory(gpxFileInformation);
geometryFactory.CreateGeometries();
var layerFactory = new LayerFactory(gpxFileInformation.WayPointsExtent);
var routes = layerFactory.CreateRoutes(path, gpxFileInformation.Routes);
mapViewModel.AddRoutes(routes);
var tracks = layerFactory.CreateTracks(path, gpxFileInformation.Tracks);
mapViewModel.AddTracks(tracks);
mapViewModel.AddPoIs(gpxFileInformation.WayPoints);
}
// ==================================================
// Helpers
private TopoTrailInfo LoadTrail(string uri)
{
// load gpx data into trail
var reader = new GpxFileReader(uri);
var data = reader.ReadFile();
var trail = new TopoTrailInfo(data);
// setup trail details
var filename = Path.GetFileNameWithoutExtension(uri);
trail.Key = filename.ToUpperInvariant();
trail.Source = uri;
return(trail);
}
public void Save_And_Check_For_POIs()
{
string fileName = "65.gpx";
string outFileName = "69.gpx";
var path = Path.Combine(UnitTestDirectory, fileName);
var gpxInfo = new GpxFileReader().LoadFile(path);
gpxInfo.WayPoints.Count.Should().Be(4);
var wayPoints = new List <wptType>();
gpxInfo.WayPoints.ForEach(x => wayPoints.Add(x));
var layer = CreateLayer(fileName);
layer.Save(wayPoints, Path.Combine(UnitTestDirectory, outFileName));
path = Path.Combine(UnitTestDirectory, outFileName);
gpxInfo = new GpxFileReader().LoadFile(path);
gpxInfo.WayPoints.Count.Should().Be(4);
}
// ==================================================
// Helpers
private TopoTrailInfo LoadTrail(FileInfo file)
{
// load gpx data into trail
var reader = new GpxFileReader(file.FullName);
var data = reader.ReadFile();
var trail = new TopoTrailInfo(data);
// setup trail details
var filename = Path.GetFileNameWithoutExtension(file.Name);
trail.Key = filename.ToUpperInvariant();
trail.Source = file.FullName;
// discover places for each track
foreach (var track in trail.TopoTracks)
{
UpdateTrackPlaces(track);
}
return(trail);
}
/// <summary>
/// Creates track edits for each track in the file data
/// </summary>
public List <TrackEditData> CreateTracks(string uri)
{
// load file and read data
var file = new FileInfo(uri);
var read = new GpxFileReader(file.FullName);
var data = read.ReadFile();
var tracks = new List <TrackEditData>();
foreach (var t in data.Tracks)
{
// create new extract entity
var track = new TrackEditData();
track.Key = Graffiti.Crypto.GetNewHash();
track.Source = t.Source;
track.Name = t.Name;
track.Description = t.Description;
track.DataPoints = t.PointData;
track.Points = t.Points;
// default missing properties
if (String.IsNullOrWhiteSpace(track.Source))
{
track.Source = file.FullName;
}
if (String.IsNullOrWhiteSpace(track.Name))
{
track.Source = Path.GetFileNameWithoutExtension(file.Name);
}
// add to edit session
_tracks.Add(track);
tracks.Add(track);
}
return(tracks);
}
static FileReaderContener()
{
IFileReader fileReader = new GpxFileReader(FilePath, XmlNamespace);
WayPoints = fileReader.ReadWayPoints().ToArray();
}
