public void Import()
        {
            importResult = new ImportResult();
              if (BeginWork != null) BeginWork(this, new EventArgs());

              // The trackpoints
              List<RouteSegment> routeSegments = new List<RouteSegment>();
              bool lastTrackpointWasInvalid = false;
              bool thisTrackpointIsInvalid = false;
              RouteSegment rs = new RouteSegment();
              int current = 0;
              int total = sessionToImport.Trackpoints.Count;
              foreach (D303_Trk_Point_Type tp in sessionToImport.Trackpoints)
              {
            Waypoint waypoint = new Waypoint();
            waypoint.Time = tp.TimeAsDateTime;
            waypoint.LongLat = new LongLat(tp.Position.LongitudeAsDegrees, tp.Position.LatitudeAsDegrees);
            waypoint.Altitude = (double)tp.Altitude;
            waypoint.HeartRate = (double)tp.HeartRate;

            thisTrackpointIsInvalid = (tp.Position.Latitude == 2147483647 && tp.Position.Longitude == 2147483647);
            if (!thisTrackpointIsInvalid) rs.Waypoints.Add(waypoint);
            if (thisTrackpointIsInvalid && lastTrackpointWasInvalid && rs.Waypoints.Count > 0)
            {
              routeSegments.Add(rs);
              rs = new RouteSegment();
            }
            lastTrackpointWasInvalid = thisTrackpointIsInvalid;
            current++;
            if (WorkProgress != null && current % 10 == 0)
            {
              WorkProgress(this, new WorkProgressEventArgs((double)current / total));
            }
              }
              if (rs.Waypoints.Count > 0)
              {
            routeSegments.Add(rs);
              }

              // The laps
              List<double> elapsedTimes = new List<double>();
              double elapsedTime = 0;
              DateTime startTime = DateTime.MinValue;
              foreach (D1001_Lap_Type xLap in sessionToImport.Laps)
              {
            if (startTime == DateTime.MinValue) startTime = xLap.StartTimeAsDateTime;
            elapsedTimes.Add(elapsedTime);
            elapsedTime += (double)xLap.TotalTime / 100;
              }
              LapCollection laps = RouteImporterUtil.CreateLapsFromElapsedTimes(startTime, elapsedTimes, routeSegments);

              importResult.Route = new Route(routeSegments);
              importResult.Laps = laps;
              importResult.Succeeded = true;
              if (EndWork != null) EndWork(this, new EventArgs());
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Opens a document stored in the old QuickRoute XML file format. This version can't save documents in this file format.
        /// </summary>
        /// <param name="fileName">The file name of the QuickRoute 1.0 xml document.</param>
        /// <param name="settings">The document settings to apply.</param>
        /// <returns></returns>
        public static Document OpenFromXml(string fileName, DocumentSettings settings)
        {
            XmlTextReader reader = null;

              RouteSegment rs = new RouteSegment();
              HandleCollection handles = new HandleCollection();
              Map map;

              try
              {

            reader = new XmlTextReader(fileName);
            reader.WhitespaceHandling = WhitespaceHandling.None;

            reader.ReadStartElement("QuickRoute");

            reader.ReadStartElement("Route");

            while (reader.Read() && reader.NodeType != XmlNodeType.EndElement)
            {
              while (reader.NodeType != XmlNodeType.Element) reader.Read();
              Waypoint t = new Waypoint();
              t.Time = DateTime.Parse(reader.GetAttribute("time"));
              t.LongLat = new LongLat();
              t.LongLat.Longitude = double.Parse(reader.GetAttribute("longitude"));
              t.LongLat.Latitude = double.Parse(reader.GetAttribute("latitude"));
              t.Altitude = double.Parse(reader.GetAttribute("altitude"));
              t.HeartRate = int.Parse(reader.GetAttribute("heartRate"));
              rs.Waypoints.Add(t);
            }
            reader.ReadEndElement();

            reader.ReadStartElement("Markers");
            while (reader.Name == "Handle")
            {
              reader.Read();
              Handle h = new Handle();
              h.ParameterizedLocation = new ParameterizedLocation(0, double.Parse(reader.GetAttribute("value")));
              reader.Read();
              double x = double.Parse(reader.GetAttribute("x"));
              double y = double.Parse(reader.GetAttribute("y"));
              h.Location = new PointD(x, y);
              reader.Read();
              h.TransformationMatrix = new GeneralMatrix(3, 3);
              h.MarkerDrawer = (new ApplicationSettings()).DefaultDocumentSettings.DefaultSessionSettings.MarkerDrawers[MarkerType.Handle];
              for (int row = 0; row < 3; row++)
              {
            for (int col = 0; col < 3; col++)
            {
              reader.Read();
              h.TransformationMatrix.SetElement(row, col, double.Parse(reader.GetAttribute("value")));
            }
              }
              reader.Read();
              reader.ReadEndElement();
              reader.ReadEndElement();
              handles.Add(h);
            }
            reader.ReadEndElement();

            map = new Map(Base64StringToBitmap(reader.ReadElementContentAsString()));

              }
              catch (Exception ex)
              {
            if (reader != null) reader.Close();
            throw new Exception(ex.Message);
              }
              reader.Close();

              List<RouteSegment> routeSegments = new List<RouteSegment>();
              routeSegments.Add(rs);
              Document doc = new Document(map, new Route(routeSegments), new LapCollection(), null, settings);
              foreach (var h in handles)
              {
            doc.Sessions[0].AddHandle(h);
              }
              doc.FileFormat = QuickRouteFileFormat.Xml;
              doc.Initialize();
              UpdateDocumentToCurrentVersion(doc);
              return doc;
        }
Ejemplo n.º 3
0
        public void Import()
        {
            importResult = new ImportResult();

              if (BeginWork != null) BeginWork(this, new EventArgs());

              XmlTextReader reader = new XmlTextReader(FileName);
              XPathDocument doc = new XPathDocument(reader);
              XPathNavigator nav = doc.CreateNavigator();
              XmlNamespaceManager nsManager = new XmlNamespaceManager(nav.NameTable);
              nsManager.AddNamespace("ns", "http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2");
              XPathNodeIterator activities = nav.Select("//ns:Activity", nsManager);

              while (activities.MoveNext())
              {
            XPathNavigator id = activities.Current.SelectSingleNode("ns:Id", nsManager);
            if (id != null && DateTime.Parse(id.Value).ToString("yyyy-MM-dd HH:mm:ss") == IdToImport)
            {
              // the activity was found

              // the laps
              XPathNodeIterator lapNodes = activities.Current.Select("ns:Lap", nsManager);
              List<RouteSegment> routeSegments = new List<RouteSegment>();
              RouteSegment routeSegment = new RouteSegment();
              while (lapNodes.MoveNext())
              {
            // the tracks
            XPathNodeIterator trackNodes = lapNodes.Current.Select("ns:Track", nsManager);
            int trackCount = 0;
            while (trackNodes.MoveNext())
            {
              if (trackCount > 0)
              {
                if (routeSegment.Waypoints.Count > 1) routeSegments.Add(routeSegment);
                routeSegment = new RouteSegment();
              }
              XPathNodeIterator trackpointNodes = trackNodes.Current.Select("ns:Trackpoint", nsManager);
              DateTime lastTime = DateTime.MinValue;
              LongLat lastLongLat = null;
              int trackpointCount = 0;
              while (trackpointNodes.MoveNext())
              {
                Waypoint waypoint = new Waypoint();
                waypoint.Time = DateTime.Parse(trackpointNodes.Current.SelectSingleNode("ns:Time", nsManager).Value).ToUniversalTime();
                XPathNavigator position = trackpointNodes.Current.SelectSingleNode("ns:Position", nsManager);
                if (position != null)
                {
                  waypoint.LongLat = new LongLat(
                    position.SelectSingleNode("ns:LongitudeDegrees", nsManager).ValueAsDouble,
                    position.SelectSingleNode("ns:LatitudeDegrees", nsManager).ValueAsDouble);
                }
                if (trackpointNodes.Current.SelectSingleNode("ns:AltitudeMeters", nsManager) != null)
                {
                  waypoint.Altitude = trackpointNodes.Current.SelectSingleNode("ns:AltitudeMeters", nsManager).ValueAsDouble;
                }
                if (trackpointNodes.Current.SelectSingleNode("ns:HeartRateBpm/ns:Value", nsManager) != null)
                {
                  waypoint.HeartRate = trackpointNodes.Current.SelectSingleNode("ns:HeartRateBpm/ns:Value", nsManager).ValueAsDouble;
                }
                if (waypoint.HeartRate == null && routeSegment.LastWaypoint != null)
                {
                  // sometimes heart rates are only present at some nodes, so use last valid heart rate
                  waypoint.HeartRate = routeSegment.LastWaypoint.HeartRate;
                }
                // do not add waypoint if it has the same location or time as the previous one
                if (waypoint.LongLat != null && !waypoint.LongLat.Equals(lastLongLat) && waypoint.Time != lastTime)
                {
                  // special handling for positionless trackpoint in the beginning, use its time together with next position
                  if (trackpointCount == 1 && lastLongLat == null && routeSegment.Waypoints.Count == 0)
                    waypoint.Time = lastTime;
                  routeSegment.Waypoints.Add(waypoint);
                }
                lastLongLat = waypoint.LongLat;
                lastTime = waypoint.Time;
                trackpointCount++;
              }
              if (lastLongLat == null && routeSegment.Waypoints.Count > 1)
              {
                // special handling for positionless trackpoint in the end, use its time together with previous position
                routeSegment.Waypoints[routeSegment.Waypoints.Count - 1].Time = lastTime;
              }
              trackCount++;
            }
              }

              // add last route segment
              if (routeSegment.Waypoints.Count > 1) routeSegments.Add(routeSegment);

              // set position of all start and end waypoints of the route segments if they are null
              foreach (RouteSegment rs in routeSegments)
              {
            if (rs.FirstWaypoint.LongLat == null && rs.Waypoints.Count > 1) rs.Waypoints[1] = rs.Waypoints[1].Clone();
            if (rs.LastWaypoint.LongLat == null && rs.Waypoints.Count > 1)
              rs.Waypoints[rs.Waypoints.Count - 1] = rs.Waypoints[rs.Waypoints.Count - 2].Clone();
              }

              // the laps
              lapNodes = activities.Current.Select("ns:Lap", nsManager);
              // first store all elapsed times
              List<double> elapsedTimes = new List<double>();
              LapCollection laps = new LapCollection();
              if (lapNodes.MoveNext())
              {
            DateTime startTime = DateTime.Parse(lapNodes.Current.GetAttribute("StartTime", "")).ToUniversalTime();
            double elapsedTime = 0;
            do
            {
              elapsedTimes.Add(elapsedTime);
              elapsedTime += lapNodes.Current.SelectSingleNode("ns:TotalTimeSeconds", nsManager).ValueAsDouble;
            } while (lapNodes.MoveNext());

            laps = RouteImporterUtil.CreateLapsFromElapsedTimes(startTime, elapsedTimes, routeSegments);
              }

              importResult.Route = new Route(routeSegments);
              importResult.Laps = laps;
              importResult.Succeeded = importResult.Route.Segments.Count > 0;
              if(importResult.Route.Segments.Count == 0) importResult.Error = ImportError.NoWaypoints;

              break;
            }
              }
              reader.Close();
              if (EndWork != null) EndWork(this, new EventArgs());
        }
Ejemplo n.º 4
0
        public void Import()
        {
            ImportResult = new ImportResult();
              if (BeginWork != null) BeginWork(this, new EventArgs());

              try
              {
            using (var stream = new FileStream(FileName, FileMode.Open, FileAccess.Read))
            {
              using (var reader = new BinaryReader(stream))
              {
            var header = new Header(reader);
            var data = new Data(reader, header.DataSize);

            // route
            var routeSegment = new RouteSegment();
            foreach(var w in data.Waypoints)
            {
              if(routeSegment.Waypoints.Count == 0 || routeSegment.LastWaypoint.Time < w.Time)
              {
                routeSegment.Waypoints.Add(new Waypoint(w.Time, new LongLat(w.Longitude, w.Latitude), w.Altitude, w.HeartRate, null, w.Cadence, w.Power));
              }
            }
            ImportResult.Route = new Route(new List<RouteSegment>() { routeSegment });

            // laps
            if (routeSegment.Waypoints.Count > 1)
            {
              ImportResult.Laps = new LapCollection();
              ImportResult.Laps.Add(new Lap(routeSegment.FirstWaypoint.Time, LapType.Start));
              foreach (var l in data.Laps)
              {
                if (l.Time > routeSegment.FirstWaypoint.Time && l.Time < routeSegment.LastWaypoint.Time)
                ImportResult.Laps.Add(new Lap(l.Time, LapType.Lap));
              }
              ImportResult.Laps.Add(new Lap(routeSegment.LastWaypoint.Time, LapType.Stop));
            }

            ImportResult.Succeeded = true;
              }
            }
              }
              catch (Exception ex)
              {
            ImportResult.Exception = ex;
              }
              if (EndWork != null) EndWork(this, new EventArgs());
        }
        private static Session ReadSession(BinaryReader reader, int length)
        {
            List<DateTime> mapReadingList = null;
              Route route = null;
              HandleCollection handles = null;
              LongLat projectionOrigin = null;
              LapCollection laps = null;
              var startPos = reader.BaseStream.Position;
              SessionInfo sessionInfo = null;
              DateTime lastTime;
              while (reader.BaseStream.Position < startPos + length)
              {
            var tag = (Tags)reader.ReadByte();
            var tagLength = Convert.ToInt32(reader.ReadUInt32());
            switch (tag)
            {
              case Tags.Route:
            var attributes = reader.ReadUInt16();
            var extraWaypointAttributesLength = reader.ReadUInt16();
            var routeSegments = new List<RouteSegment>();
            var segmentCount = reader.ReadUInt32();
            lastTime = DateTime.MinValue;
            for (var i = 0; i < segmentCount; i++)
            {
              var rs = new RouteSegment();
              var waypointCount = reader.ReadUInt32();
              for (var j = 0; j < waypointCount; j++)
              {
                var w = new Waypoint();
                w.LongLat = ReadLongLat(reader);
                w.Time = ReadTime(lastTime, reader);
                lastTime = w.Time;
                if ((attributes & (UInt16)WaypointAttribute.HeartRate) == (UInt16)WaypointAttribute.HeartRate)
                {
                  w.HeartRate = reader.ReadByte();
                }
                if ((attributes & (UInt16)WaypointAttribute.Altitude) == (UInt16)WaypointAttribute.Altitude)
                {
                  w.Altitude = reader.ReadInt16();
                }
                reader.BaseStream.Position += extraWaypointAttributesLength; // for forward compatibility
                rs.Waypoints.Add(w);
              }
              routeSegments.Add(rs);
            }
            route = new Route(routeSegments);
            break;

              case Tags.Handles:
            handles = new HandleCollection();
            var handleCount = reader.ReadUInt32();
            var handleMarkerDrawer = SessionSettings.CreateDefaultMarkerDrawers()[MarkerType.Handle];
            for (var i = 0; i < handleCount; i++)
            {
              var handle = new Handle();
              // transformation matrix
              handle.TransformationMatrix = new GeneralMatrix(3, 3);
              for (var j = 0; j < 9; j++)
              {
                handle.TransformationMatrix.SetElement(j / 3, j % 3, reader.ReadDouble());
              }
              // parameterized location
              var segmentIndex = Convert.ToInt32(reader.ReadUInt32());
              var value = reader.ReadDouble();
              handle.ParameterizedLocation = new ParameterizedLocation(segmentIndex, value);

              // pixel location
              handle.Location = new PointD(reader.ReadDouble(), reader.ReadDouble());
              // type
              handle.Type = (Handle.HandleType)reader.ReadInt16();
              // use default marker drawer
              handle.MarkerDrawer = handleMarkerDrawer;

              handles.Add(handle);
            }
            break;

              case Tags.ProjectionOrigin:
            projectionOrigin = ReadLongLat(reader);
            break;

              case Tags.Laps:
            laps = new LapCollection();
            var lapCount = reader.ReadUInt32();
            for (var i = 0; i < lapCount; i++)
            {
              var lap = new Lap();
              lap.Time = DateTime.FromBinary(reader.ReadInt64());
              lap.LapType = (LapType)reader.ReadByte();
              laps.Add(lap);
            }
            break;

              case Tags.SessionInfo:
            sessionInfo = new SessionInfo();
            sessionInfo.Person = new SessionPerson();
            sessionInfo.Person.Name = ReadString(reader);
            sessionInfo.Person.Club = ReadString(reader);
            sessionInfo.Person.Id = reader.ReadUInt32();
            sessionInfo.Description = ReadString(reader);
            // when more fields are added, check so that tagLength is not passed
            break;

              case Tags.MapReadingInfo:
            mapReadingList = new List<DateTime>();
            lastTime = DateTime.MinValue;
            var startPosition = reader.BaseStream.Position;
            while (reader.BaseStream.Position - startPosition < tagLength)
            {
              var time = ReadTime(lastTime, reader);
              mapReadingList.Add(time);
              lastTime = time;
            }
            break;

              default:
            reader.BaseStream.Position += tagLength;
            break;
            }
              }

              if(mapReadingList != null && route != null) route = new Route(Route.AddMapReadingWaypoints(route.Segments, mapReadingList));
              var session = new Session(
            route,
            laps,
            new Size(0, 0),
            handles != null && handles.Count > 0 ? handles[0].TransformationMatrix : null,
            projectionOrigin,
            new SessionSettings());
              if (handles != null)
              {
            foreach (var h in handles)
            {
              session.AddHandle(h);
            }
              }
              if (sessionInfo != null) session.SessionInfo = sessionInfo;

              return session;
        }
Ejemplo n.º 6
0
        /*
        private void ImportGPX10()
        {
          if (BeginWork != null) BeginWork(this, new EventArgs());

          NumberFormatInfo nfi = new NumberFormatInfo();
          nfi.NumberDecimalSeparator = ".";
          XmlTextReader sr = new XmlTextReader(fileName);
          XmlSerializer xSerializer = new XmlSerializer(typeof(gpx10Type));
          gpx10Type gpx = (gpx10Type)xSerializer.Deserialize(sr);
          sr.Close();
          XmlNamespaceManager nsManager = new XmlNamespaceManager(sr.NameTable);
          nsManager.AddNamespace("st", "urn:uuid:D0EB2ED5-49B6-44e3-B13C-CF15BE7DD7DD");

          importResult = new ImportResult();

          // route
          List<RouteSegment> routeSegments = new List<RouteSegment>();
          foreach (gpxTrk trk in gpx.trk)
          {
        for (int i = trk.trkseg.GetLowerBound(0); i <= trk.trkseg.GetUpperBound(0); i++)
        {
          RouteSegment routeSegment = new RouteSegment();
          for (int j = trk.trkseg.GetLowerBound(1); j <= trk.trkseg.GetUpperBound(1); j++)
          {
            gpxTrkTrksegTrkpt wpt = trk.trkseg[i][j];
            double lat = (double)wpt.lat;
            double lon = (double)wpt.lon;
            DateTime time = wpt.time;
            double? heartRate = null;
            double? altitude = null;
            routeSegment.Waypoints.Add(new Waypoint(time, new LongLat(lon, lat), altitude, heartRate));
          }
          routeSegments.Add(routeSegment);
        }
          }
          importResult.Route = new Route(routeSegments);

          // laps
          LapCollection laps = new LapCollection();
          importResult.Laps = laps;

          if (EndWork != null) EndWork(this, new EventArgs());
        }
        */
        private void ImportGPX11()
        {
            ImportResult = new ImportResult();
              var isGPX10 = (GPXUtil.GetGPXVersion(fileName) == GPXVersion.GPX10);
              string gpx10convertedFileName = null;
              string polarConvertedFileName = null;
              var originalFileName = fileName;
              if (BeginWork != null) BeginWork(this, new EventArgs());

              // check if the file is in gpx 1.0 format and convert it to gpx 1.1 if necessary
              if (isGPX10)
              {
            gpx10convertedFileName = Path.GetTempFileName();
            GPXUtil.ConvertGPX10ToGPX11(fileName, gpx10convertedFileName);
            fileName = gpx10convertedFileName;
              }

              // check if the file is an invalid Polar ProTrainer file and correct if necessary
              if (PolarProTrainerUtil.IsPolarProTrainerGPXFile(fileName))
              {
            polarConvertedFileName = Path.GetTempFileName();
            PolarProTrainerUtil.CorrectPolarProTrainerGPXFile(fileName, polarConvertedFileName);
            fileName = polarConvertedFileName;
              }

              var nfi = new NumberFormatInfo { NumberDecimalSeparator = "." };
              var sr = new XmlTextReader(fileName);
              var xSerializer = new XmlSerializer(typeof(gpx11Type));
              var gpx11 = (gpx11Type)xSerializer.Deserialize(sr);
              sr.Close();
              var nsManager = new XmlNamespaceManager(sr.NameTable);
              // add namespace for split times and heart rates (from SportsTracks software)
              nsManager.AddNamespace("st", "urn:uuid:D0EB2ED5-49B6-44e3-B13C-CF15BE7DD7DD");
              // add namespace for map reading information (QuickRoute native)
              nsManager.AddNamespace("mr", "http://www.matstroeng.se/quickroute/map-reading");

              // pre-store heart rates in dictionary (if present)
              var heartRates = new Dictionary<DateTime, double>();
              // pre-store map-readings in map reading collection (if present)
              var mapReadings = new List<DateTime>();
              if (gpx11.extensions != null && gpx11.extensions.Any != null)
              {
            foreach (var element in gpx11.extensions.Any)
            {
              if (element.Name == "st:activity")
              {
            var nodes = element.SelectNodes("st:heartRateTrack/st:heartRate[@time and @bpm]", nsManager);
            if (nodes != null)
            {
              foreach (XmlNode node in nodes)
              {
                DateTime time;
                double bpm;
                if (DateTime.TryParse(node.Attributes["time"].Value, out time) &&
                    double.TryParse(node.Attributes["bpm"].Value, NumberStyles.Any, nfi, out bpm))
                {
                  time = time.ToUniversalTime();
                  if(!heartRates.ContainsKey(time)) heartRates.Add(time, bpm);
                }
              }
            }
              }
              if(element.Name == "mr:map-reading")
              {
            DateTime start, end;
            if (DateTime.TryParse(element.Attributes["start"].Value, out start) &&
                DateTime.TryParse(element.Attributes["end"].Value, out end))
            {
              mapReadings.Add(start.ToUniversalTime());
              mapReadings.Add(end.ToUniversalTime());
            }
              }
            }
              }
              mapReadings = FilterMapReadings(mapReadings);

              // QuickRoute route
              var noOfWaypoints = 0;
              var noOfWaypointsWithTimes = 0;
              var routeSegments = new List<RouteSegment>();

              // first use GPX track
              if (gpx11.trk != null)
              {
            foreach (var trk in gpx11.trk)
            {
              // Garmin Training Center exports each lap as a separate trkseg with end time of trkseg n equal to start time of trkseg n+1
              // handle this issue

              foreach (var trkseg in trk.trkseg)
              {
            var routeSegment = new RouteSegment();
            wptType lastWpt = null;
            if (trkseg.trkpt != null)
            {
              foreach (var wpt in trkseg.trkpt)
              {
                if (lastWpt == null || wpt.time != lastWpt.time)
                {
                  if (wpt.extensions != null && wpt.extensions.Any != null && wpt.extensions.Any[0].LocalName == "timerPaused")
                  {
                    // new route segment ahead
                    if (routeSegment.Waypoints.Count > 0) routeSegments.Add(routeSegment);
                    routeSegment = new RouteSegment();
                  }
                  else
                  {
                    var lat = (double)wpt.lat;
                    var lon = (double)wpt.lon;
                    double? heartRate = null;
                    double? altitude = null;
                    // check for heartrate in SportsTracks extensions
                    if (heartRates.ContainsKey(wpt.time)) heartRate = heartRates[wpt.time];
                    // check for heartrate in Garmin Trackpoint Extensions
                    heartRate = GetGarminHeartRateFromWaypoint(wpt) ?? heartRate;

                    if (wpt.eleSpecified)
                    {
                      altitude = (double?)wpt.ele;
                    }
                    if (wpt.timeSpecified)
                    {
                      routeSegment.Waypoints.Add(new Waypoint(wpt.time, new LongLat(lon, lat), altitude, heartRate, null));
                      noOfWaypointsWithTimes++;
                      lastWpt = wpt;
                    }
                  }
                  noOfWaypoints++;
                }
              }
            }
            if (routeSegment.Waypoints.Count > 0) routeSegments.Add(routeSegment);
              }
            }
              }

              // if no GPX track - use GPX route
              if (noOfWaypointsWithTimes == 0 && gpx11.rte != null)
              {
            foreach (var route in gpx11.rte)
            {
              var routeSegment = new RouteSegment();
              foreach (var rtept in route.rtept)
              {
            if (rtept.extensions != null && rtept.extensions.Any != null && rtept.extensions.Any[0].LocalName == "timerPaused")
            {
              // new route segment ahead
              if (routeSegment.Waypoints.Count > 0) routeSegments.Add(routeSegment);
              routeSegment = new RouteSegment();
            }
            else
            {
              var lat = (double) rtept.lat;
              var lon = (double) rtept.lon;
              double? heartRate = null;
              double? altitude = null;
              if (heartRates.ContainsKey(rtept.time)) heartRate = heartRates[rtept.time];
              if (rtept.eleSpecified)
              {
                altitude = (double?) rtept.ele;
              }
              if (rtept.timeSpecified)
              {
                routeSegment.Waypoints.Add(new Waypoint(rtept.time, new LongLat(lon, lat), altitude, heartRate, null));
                noOfWaypointsWithTimes++;
              }
            }
            noOfWaypoints++;
              }
              if (routeSegment.Waypoints.Count > 0) routeSegments.Add(routeSegment);
            }
              }

              // add map reading waypoints
              routeSegments = Route.AddMapReadingWaypoints(routeSegments, mapReadings);

              // concat route segments if they are close enough (oddly enough, Garmin Training Center v2 seems to create a trkseg for each lap)
              var lapsFromConcatenatedRouteSegments = new List<Lap>();
              if (routeSegments.Count > 0)
              {
            var concatenatedRouteSegments = new List<RouteSegment>() { routeSegments[0] };
            for (var i = 1; i < routeSegments.Count; i++)
            {
              if (concatenatedRouteSegments[concatenatedRouteSegments.Count - 1].LastWaypoint.Time.AddSeconds(10) > routeSegments[i].FirstWaypoint.Time)
              {
            lapsFromConcatenatedRouteSegments.Add(new Lap(concatenatedRouteSegments[concatenatedRouteSegments.Count - 1].LastWaypoint.Time, LapType.Lap));
            concatenatedRouteSegments[concatenatedRouteSegments.Count - 1].Waypoints.AddRange(routeSegments[i].Waypoints);
              }
            }
            routeSegments = concatenatedRouteSegments;
              }

              importResult.Succeeded = (noOfWaypointsWithTimes > 0);

              if (ImportResult.Succeeded)
              {
            importResult.Route = new Route(routeSegments);

            // laps
            var laps = new LapCollection();
            var startTime = ImportResult.Route.FirstWaypoint.Time;

            // from GPX st:split
            if (gpx11.extensions != null && gpx11.extensions.Any != null)
            {
              foreach (var element in gpx11.extensions.Any)
              {
            if (element.Name == "st:activity")
            {
              var nodes = element.SelectNodes("st:splits/st:split[@time]", nsManager);
              if (nodes != null)
              {
                foreach (XmlNode node in nodes)
                {
                  var elapsedTime = double.Parse(node.Attributes["time"].Value, nfi);
                  var lap = new Lap(startTime.AddSeconds(elapsedTime), LapType.Lap);
                  laps.Add(lap);
                }
              }
            }
              }
            }

            // from GPX waypoints
            if (gpx11.wpt != null && laps.Count == 0)
            {
              foreach (var waypoint in gpx11.wpt)
              {
            if (waypoint.timeSpecified)
            {
              laps.Add(new Lap(waypoint.time, LapType.Lap));
            }
              }
            }

            laps.AddRange(lapsFromConcatenatedRouteSegments);

            foreach (var rs in routeSegments)
            {
              laps.Add(new Lap(rs.FirstWaypoint.Time, LapType.Start));
              laps.Add(new Lap(rs.LastWaypoint.Time, LapType.Stop));
            }
            importResult.Laps = laps;
              }
              else
              {
            if (noOfWaypoints == 0)
            {
              importResult.Error = ImportError.NoWaypoints;
            }
            else if (noOfWaypointsWithTimes == 0)
            {
              importResult.Error = ImportError.NoWaypointTimes;
            }
              }

              if (gpx10convertedFileName != null)
              {
            File.Delete(gpx10convertedFileName);
            fileName = originalFileName;
              }

              if (polarConvertedFileName != null)
              {
            File.Delete(polarConvertedFileName);
            fileName = originalFileName;
              }

              // import Polar HRM file with same base file name as the gpx file, if existing
              var extension = new FileInfo(fileName).Extension;
              if(extension != "")
              {
            string hrmFileName = new FileInfo(fileName).FullName.Replace(extension, ".hrm");
            if(File.Exists(hrmFileName))
            {
              new PolarHRMImporter().AddLapsAndHRData(hrmFileName, importResult);
            }
              }

              if (EndWork != null) EndWork(this, new EventArgs());
        }
Ejemplo n.º 7
0
        public void Import()
        {
            importResult = new ImportResult();
              if (BeginWork != null) BeginWork(this, new EventArgs());
              StreamReader reader = new StreamReader(FileName);
              RouteSegment rs = new RouteSegment();
              LapCollection laps = new LapCollection();
              int i;
              string[] atoms;
              string line;

              for (i = 0; i < 3; i++) reader.ReadLine();

              // start time
              atoms = reader.ReadLine().Split("\t".ToCharArray());
              DateTime startTime = DateTime.MinValue;
              int firstColonPosition = atoms[1].IndexOf(":");
              int lastColonPosition = atoms[1].LastIndexOf(":");
              int length = lastColonPosition + 2 - firstColonPosition + 2 + 1;
              if (length > 0)
              {
            if(DateTime.TryParse(atoms[1].Substring(firstColonPosition - 2, lastColonPosition + 2 - firstColonPosition + 2 + 1), out startTime))
            {
              startTime = startTime.ToUniversalTime();
            }
              }

              // go to start of coordinates
              i = 0;
              while (i < 5 && !reader.EndOfStream)
              {
            line = reader.ReadLine();
            if (line == "") i++;
              }
              reader.ReadLine();
              reader.ReadLine();

              // read all coordinates
              while (!reader.EndOfStream)
              {
            line = reader.ReadLine();
            if (line == "") break;
            atoms = line.Split("\t".ToCharArray());
            Waypoint w = new Waypoint();
            w.Time = startTime.AddSeconds(Convert.ToInt32(atoms[0]));
            w.LongLat = new LongLat(ParseFRWDLongLatString(atoms[5]), ParseFRWDLongLatString(atoms[4]));
            double altitude;
            double.TryParse(LocalizeDecimalString(atoms[6]), out altitude);
            w.Altitude = altitude;
            double heartRate;
            double.TryParse(LocalizeDecimalString(atoms[9]), out heartRate);
            w.HeartRate = heartRate;
            rs.Waypoints.Add(w);

            if (atoms[1] != "")
            {
              // lap
              Lap lap = new Lap();
              lap.LapType = LapType.Lap;
              lap.Time = w.Time;
              laps.Add(lap);
            }
              }

              if (laps.Count > 0) laps[0].LapType = LapType.Start;
              if (laps.Count > 1) laps[laps.Count - 1].LapType = LapType.Stop;

              importResult.Laps = laps;
              List<RouteSegment> routeSegments = new List<RouteSegment>();
              if(rs.Waypoints.Count > 0)
              {
            routeSegments.Add(rs);
            importResult.Route = new Route(routeSegments);
            importResult.Succeeded = true;
              }
              else
              {
            importResult.Succeeded = false;
            importResult.Error = ImportError.NoWaypoints;
              }

              reader.Close();
              if (EndWork != null) EndWork(this, new EventArgs());
        }
Ejemplo n.º 8
0
        public CutRouteData Cut(ParameterizedLocation parameterizedLocation, CutType cutType)
        {
            var cutRoute = new CutRouteData { CutType = cutType };
              switch (cutType)
              {
            case CutType.Before:
              cutRoute.Segments.AddRange(segments.GetRange(0, parameterizedLocation.SegmentIndex));
              if (!parameterizedLocation.IsNode)
              {
            // cut between two waypoints: create cut waypoint
            Waypoint cutWaypoint = CreateWaypointFromParameterizedLocation(parameterizedLocation);
            var rs = new RouteSegment();
            segments.RemoveRange(0, parameterizedLocation.SegmentIndex);
            rs.Waypoints.AddRange(segments[0].Waypoints.GetRange(0, (int)parameterizedLocation.Ceiling().Value));
            cutRoute.Segments.Add(rs);
            segments[0].Waypoints.RemoveRange(0, (int)parameterizedLocation.Ceiling().Value);
            segments[0].Waypoints.Insert(0, cutWaypoint);
            cutRoute.WaypointInsertedAtCut = cutWaypoint;
              }
              else
              {
            // cut exactly at a waypoint
            var rs = new RouteSegment();
            segments.RemoveRange(0, parameterizedLocation.SegmentIndex);
            rs.Waypoints.AddRange(segments[0].Waypoints.GetRange(0, (int)parameterizedLocation.Value));
            cutRoute.Segments.Add(rs);
            segments[0].Waypoints.RemoveRange(0, (int)parameterizedLocation.Value);
              }
              // handle map readings nicely
              if (waypointAttributeExists[WaypointAttribute.MapReadingDuration] &&
             segments[0].FirstWaypoint.MapReadingState == MapReadingState.Reading)
              {
            segments[0].FirstWaypoint.MapReadingState = MapReadingState.StartReading;
              }
              break;

            case CutType.After:
              if (parameterizedLocation.SegmentIndex < segments.Count - 1)
              {
            cutRoute.Segments.AddRange(segments.GetRange(parameterizedLocation.SegmentIndex + 1,
                                                         segments.Count - 1 - parameterizedLocation.SegmentIndex));
            segments.RemoveRange(parameterizedLocation.SegmentIndex + 1,
                                 segments.Count - 1 - parameterizedLocation.SegmentIndex);
              }
              var i = (int)parameterizedLocation.Ceiling().Value;
              int count = segments[parameterizedLocation.SegmentIndex].Waypoints.Count;
              if (!parameterizedLocation.IsNode)
              {
            // cut between two waypoints: create cut waypoint
            Waypoint cutWaypoint = CreateWaypointFromParameterizedLocation(parameterizedLocation);
            var rs = new RouteSegment();
            rs.Waypoints.AddRange(segments[parameterizedLocation.SegmentIndex].Waypoints.GetRange(i, count - i));
            cutRoute.Segments.Insert(0, rs);
            segments[parameterizedLocation.SegmentIndex].Waypoints.RemoveRange(i, count - i);
            segments[parameterizedLocation.SegmentIndex].Waypoints.Insert(i, cutWaypoint);
            cutRoute.WaypointInsertedAtCut = cutWaypoint;
              }
              else
              {
            // cut exactly at a waypoint
            var rs = new RouteSegment();
            rs.Waypoints.AddRange(segments[parameterizedLocation.SegmentIndex].Waypoints.GetRange(i + 1, count - 1 - i));
            cutRoute.Segments.Insert(0, rs);
            segments[parameterizedLocation.SegmentIndex].Waypoints.RemoveRange(i + 1, count - 1 - i);
              }
              // handle map readings nicely
              var lastWaypoint = segments[segments.Count - 1].LastWaypoint;
              if (waypointAttributeExists[WaypointAttribute.MapReadingDuration] &&
             lastWaypoint.MapReadingState == MapReadingState.Reading)
              {
            lastWaypoint.MapReadingState = MapReadingState.EndReading;
              }
              break;
              }
              return cutRoute;
        }
Ejemplo n.º 9
0
 public static List<RouteSegment> AddMapReadingWaypoints(List<RouteSegment> routeSegments, List<DateTime> mapReadings)
 {
     if (mapReadings.Count == 0) return routeSegments;
       var newRouteSegments = new List<RouteSegment>();
       foreach (var routeSegment in routeSegments)
       {
     var newRouteSegment = new RouteSegment();
     var waypointCount = 0;
     var mapReadingIndex = -1; // just to be sure, could probably be removed
     foreach (var waypoint in routeSegment.Waypoints)
     {
       while (mapReadingIndex < mapReadings.Count - 1 && mapReadings[mapReadingIndex+1] <= waypoint.Time)
       {
     mapReadingIndex++;
       }
       var newWaypoint = waypoint.Clone();
       if (waypoint == routeSegment.FirstWaypoint)
       {
     newWaypoint.MapReadingState = mapReadingIndex % 2 == 0 ? MapReadingState.StartReading : MapReadingState.NotReading;
     newRouteSegment.Waypoints.Add(newWaypoint);
       }
       else if (waypoint == routeSegment.LastWaypoint)
       {
     newWaypoint.MapReadingState = newRouteSegment.LastWaypoint.MapReadingState == MapReadingState.StartReading || newRouteSegment.LastWaypoint.MapReadingState == MapReadingState.Reading
                                  ? MapReadingState.EndReading
                                  : MapReadingState.NotReading;
     newRouteSegment.Waypoints.Add(newWaypoint);
     break;
       }
       else
       {
     if (mapReadingIndex != -1 && mapReadings[mapReadingIndex] == newWaypoint.Time)
     {
       newWaypoint.MapReadingState = mapReadingIndex % 2 == 0 ? MapReadingState.StartReading : MapReadingState.EndReading;
     }
     else
     {
       newWaypoint.MapReadingState = mapReadingIndex % 2 == 0 ? MapReadingState.Reading : MapReadingState.NotReading;
     }
     newRouteSegment.Waypoints.Add(newWaypoint);
       }
       var nextWaypoint = routeSegment.Waypoints[waypointCount + 1];
       while (mapReadingIndex < mapReadings.Count - 1 && mapReadings[mapReadingIndex + 1] < nextWaypoint.Time)
       {
     var time = mapReadings[mapReadingIndex + 1];
     var t = (double)(time - waypoint.Time).Ticks / (nextWaypoint.Time - waypoint.Time).Ticks;
     var longLat = (1 - t) * waypoint.LongLat + t * nextWaypoint.LongLat;
     var altitude = waypoint.Altitude.HasValue && nextWaypoint.Altitude.HasValue
       ? (double?)((1 - t) * waypoint.Altitude.Value + t * nextWaypoint.Altitude.Value)
       : null;
     var heartRate = waypoint.HeartRate.HasValue && nextWaypoint.HeartRate.HasValue
       ? (double?)((1 - t) * waypoint.HeartRate.Value + t * nextWaypoint.HeartRate.Value)
       : null;
     var mapReadingState = (mapReadingIndex + 1) % 2 == 0 ? MapReadingState.StartReading : MapReadingState.EndReading;
     newRouteSegment.Waypoints.Add(new Waypoint(time, longLat, altitude, heartRate, mapReadingState, null, null));
     mapReadingIndex++;
       }
       waypointCount++;
     }
     newRouteSegments.Add(newRouteSegment);
       }
       return newRouteSegments;
 }