Beispiel #1
0
        static public GpxFile Load (Stream stream)
        {
            XmlDocument xmlDoc = new XmlDocument ();
            xmlDoc.Load(stream);

            IGpxDataTranslator gpxDataTranslator = null;
            switch (xmlDoc.DocumentElement.NamespaceURI)
            {
                case "http://www.topografix.com/GPX/1/1":
                    gpxDataTranslator = new Gpx11DataTranslator();
                    break;
                case "http://www.topografix.com/GPX/1/0":
                    gpxDataTranslator = new Gpx10DataTranslator ();
                    break;
                    //throw new NotSupportedException ("GPX version 1.0 is currently not supported. Please use a 3rd party tool (like gpsbabel) to convert it to 1.1 format.");
                default:
                    throw new ArgumentException("This is not a GPX file.");
            }

            // move back to the start of the stream
            stream.Seek(0, SeekOrigin.Begin);
            GpxFile gpxFile = new GpxFile ();
            gpxDataTranslator.ReadGpxData(gpxFile, stream);
            return gpxFile;
        }
        public void ReadGpxData(GpxFile gpxFile, Stream stream)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(gpx));
            gpx           gpx        = (gpx)serializer.Deserialize(stream);

            if (gpx.trk != null)
            {
                foreach (gpxTrk trkType in gpx.trk)
                {
                    Track track = new Track();

                    foreach (gpxTrkTrkseg trkseg in trkType.trkseg)
                    {
                        if (trkseg.trkpt.Length > 0)
                        {
                            TrackSegment segment = new TrackSegment();
                            foreach (gpxTrkTrksegTrkpt trkpt in trkseg.trkpt)
                            {
                                TrackPoint waypoint = ReadTrackPoint(trkpt);
                                segment.AddPoint(waypoint);
                            }

                            track.AddSegment(segment);
                        }
                    }

                    gpxFile.AddTrack(track);
                }
            }

            if (gpx.wpt != null)
            {
                foreach (gpxWpt wptType in gpx.wpt)
                {
                    TrackPoint waypoint = ReadWayoint(wptType);
                    gpxFile.AddWaypoint(waypoint);
                }
            }

            if (gpx.rte != null)
            {
                foreach (gpxRte rteType in gpx.rte)
                {
                    Track route = new Track();

                    if (rteType.rtept != null)
                    {
                        TrackSegment segment = new TrackSegment();
                        foreach (gpxRteRtept wptType in rteType.rtept)
                        {
                            TrackPoint waypoint = ReadRoutePoint(wptType);
                            segment.AddPoint(waypoint);
                        }
                    }

                    gpxFile.AddRoute(route);
                }
            }
        }
 public void WriteGpxData(GpxFile gpxFile, string fileName)
 {
     throw new System.NotImplementedException();
 }
        public void WriteGpxData(GpxFile gpxFile, string fileName)
        {
            gpxType gpx = new gpxType();

            List <trkType> destTracks = new List <trkType>();

            // tracks
            foreach (Track track in gpxFile.Tracks)
            {
                List <trksegType> destSegments = new List <trksegType>();

                foreach (TrackSegment segment in track.Segments)
                {
                    trksegType     destSegment   = new trksegType();
                    List <wptType> destWaypoints = new List <wptType>();

                    foreach (TrackPoint point in segment.Points)
                    {
                        destWaypoints.Add(SaveTrackPoint(point));
                    }

                    destSegment.trkpt = destWaypoints.ToArray();
                    destSegments.Add(destSegment);
                }

                if (destSegments.Count > 0)
                {
                    trkType destTrack = new trkType();
                    destTrack.trkseg = destSegments.ToArray();
                    destTracks.Add(destTrack);
                }
            }

            if (destTracks.Count > 0)
            {
                gpx.trk = destTracks.ToArray();
            }

            // waypoints
            List <wptType> destWaypoints2 = new List <wptType>();

            foreach (TrackPoint waypoint in gpxFile.Waypoints)
            {
                destWaypoints2.Add(SaveTrackPoint(waypoint));
            }

            if (destWaypoints2.Count > 0)
            {
                gpx.wpt = destWaypoints2.ToArray();
            }

            // routes
            List <rteType> destRoutes = new List <rteType>();

            foreach (Track route in gpxFile.Routes)
            {
                List <wptType> destRoutePoints = new List <wptType>();

                foreach (TrackSegment segment in route.Segments)
                {
                    foreach (TrackPoint routePoint in segment.Points)
                    {
                        destRoutePoints.Add(SaveTrackPoint(routePoint));
                    }
                }

                if (destRoutePoints.Count > 0)
                {
                    rteType destRoute = new rteType();
                    destRoute.rtept = destRoutePoints.ToArray();
                    destRoutes.Add(destRoute);
                }
            }

            if (destRoutes.Count > 0)
            {
                gpx.rte = destRoutes.ToArray();
            }

            using (FileStream stream = File.Open(fileName, FileMode.Create))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(gpxType));
                serializer.Serialize(stream, gpx);
            }
        }
        public void ReadGpxData(GpxFile gpxFile, Stream stream)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(gpxType));
            gpxType       gpx        = (gpxType)serializer.Deserialize(stream);

            if (gpx.trk != null)
            {
                foreach (trkType trkType in gpx.trk)
                {
                    Track track = new Track();

                    if (trkType.trkseg != null)
                    {
                        foreach (trksegType trksegType in trkType.trkseg)
                        {
                            if (trksegType.trkpt != null)
                            {
                                TrackSegment segment = new TrackSegment();
                                foreach (wptType wptType in trksegType.trkpt)
                                {
                                    TrackPoint waypoint = ReadTrackPoint(wptType);
                                    segment.AddPoint(waypoint);
                                }

                                track.AddSegment(segment);
                            }
                        }
                    }

                    gpxFile.AddTrack(track);
                }
            }

            if (gpx.wpt != null)
            {
                foreach (wptType wptType in gpx.wpt)
                {
                    TrackPoint waypoint = ReadTrackPoint(wptType);
                    gpxFile.AddWaypoint(waypoint);
                }
            }

            if (gpx.rte != null)
            {
                foreach (rteType rteType in gpx.rte)
                {
                    Track route = new Track();

                    if (rteType.rtept != null)
                    {
                        TrackSegment segment = new TrackSegment();
                        foreach (wptType wptType in rteType.rtept)
                        {
                            TrackPoint waypoint = ReadTrackPoint(wptType);
                            segment.AddPoint(waypoint);
                        }

                        route.AddSegment(segment);
                    }

                    gpxFile.AddRoute(route);
                }
            }
        }