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
 private double GetYValue(Waypoint w)
 {
     switch (yAxisAttribute)
       {
     case WaypointAttribute.Speed:
       return w.Attributes[WaypointAttribute.Speed].Value;
     case WaypointAttribute.HeartRate:
       return w.Attributes[WaypointAttribute.HeartRate].GetValueOrDefault(0);
     case WaypointAttribute.Altitude:
       return w.Attributes[WaypointAttribute.Altitude].GetValueOrDefault(0);
     case WaypointAttribute.DirectionDeviationToNextLap:
       return w.Attributes[WaypointAttribute.DirectionDeviationToNextLap].Value;
     case WaypointAttribute.MapReadingDuration:
       return w.Attributes[WaypointAttribute.MapReadingDuration].GetValueOrDefault(0);
     case WaypointAttribute.Cadence:
       return w.Attributes[WaypointAttribute.Cadence].GetValueOrDefault(0);
     case WaypointAttribute.Power:
       return w.Attributes[WaypointAttribute.Power].GetValueOrDefault(0);
     case WaypointAttribute.Pace:
     default:
       return ConvertUtil.ToPace(w.Attributes[WaypointAttribute.Speed].Value).TotalSeconds;
       }
 }
Ejemplo n.º 4
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.º 5
0
 private KmlMarkerStyle GetMarkerStyleFromWaypoint(Waypoint waypoint, ImageExporter imageExporter, SessionSettings sessionSettings)
 {
     var attribute = imageExporter.Properties.ColorCodingAttribute;
       var rls = sessionSettings.RouteLineSettingsCollection[attribute];
       return new KmlMarkerStyle()
       {
     Color = rls.ColorRange.GetColor(waypoint.Attributes[attribute].GetValueOrDefault(0), NoOfColorCodedSteps),
     Size = replayMarkerSizeFactor * ((rls.MaskVisible ? 2 * rls.MaskWidth : 0) + rls.Width)
       };
 }
Ejemplo n.º 6
0
 private double GetXValue(Waypoint w)
 {
     switch (xAxisAttribute)
       {
     case DomainAttribute.ElapsedTime:
       return w.Attributes[WaypointAttribute.ElapsedTime].Value;
     case DomainAttribute.Distance:
       return w.Attributes[WaypointAttribute.Distance].Value;
     case DomainAttribute.TimeOfDay:
     default:
       return (double)w.Time.ToLocalTime().Ticks / TimeSpan.TicksPerSecond;
       }
 }
Ejemplo n.º 7
0
 private void CreateReplayPlacemark(Waypoint waypoint, KmlMarkerStyle style, XmlWriter writer, IFormatProvider formatProvider)
 {
     CreateReplayPlacemark(waypoint, style, null, null, writer, formatProvider);
 }
Ejemplo n.º 8
0
 private void CreateReplayPlacemark(Waypoint waypoint, KmlMarkerStyle style, DateTime? appearTime, DateTime? disappearTime, XmlWriter writer, IFormatProvider formatProvider)
 {
     writer.WriteStartElement("Placemark");
       writer.WriteElementString("styleUrl", "#" + GetMarkerStyleId(style));
       if (appearTime.HasValue || disappearTime.HasValue)
       {
     writer.WriteStartElement("TimeSpan");
     if (appearTime.HasValue) writer.WriteElementString("begin", FormatTime(appearTime.Value.ToUniversalTime()));
     if (disappearTime.HasValue) writer.WriteElementString("end", FormatTime(disappearTime.Value.ToUniversalTime()));
     writer.WriteEndElement(); // TimeSpan
       }
       else
       {
     writer.WriteStartElement("TimeStamp");
     writer.WriteElementString("when", FormatTime(waypoint.Time.ToUniversalTime()));
     writer.WriteEndElement(); // TimeStamp
       }
       writer.WriteStartElement("Point");
       writer.WriteElementString("coordinates",
     waypoint.LongLat.Longitude.ToString(formatProvider) + "," +
     waypoint.LongLat.Latitude.ToString(formatProvider));
       writer.WriteEndElement(); // Point
       writer.WriteEndElement(); // Placemark
 }
        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.º 10
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.º 11
0
        public Waypoint CreateWaypointFromParameterizedLocation(ParameterizedLocation parameterizedLocation)
        {
            var w = new Waypoint();
              List<Waypoint> waypoints = segments[parameterizedLocation.SegmentIndex].Waypoints;
              var i = (int)parameterizedLocation.Floor().Value;
              if (i >= waypoints.Count - 1) i = waypoints.Count - 2;
              if (waypoints.Count < 2) return waypoints[0];
              double d = parameterizedLocation.Value - i;

              // time
              DateTime dt0 = waypoints[i].Time;
              DateTime dt1 = waypoints[i + 1].Time;
              w.Time = new DateTime(dt0.Ticks + (long)(d * (dt1.Ticks - dt0.Ticks)), dt0.Kind);

              // location
              LongLat p0 = waypoints[i].LongLat;
              LongLat p1 = waypoints[i + 1].LongLat;
              w.LongLat = new LongLat(p0.Longitude + d * (p1.Longitude - p0.Longitude),
                              p0.Latitude + d * (p1.Latitude - p0.Latitude));

              // altitude
              if (waypoints[i].Altitude.HasValue && waypoints[i + 1].Altitude.HasValue)
              {
            w.Altitude = waypoints[i].Altitude + d * (waypoints[i + 1].Altitude - waypoints[i].Altitude);
              }

              // heart rate
              if (waypoints[i].HeartRate.HasValue && waypoints[i + 1].HeartRate.HasValue)
              {
            w.HeartRate = waypoints[i].HeartRate + d * (waypoints[i + 1].HeartRate - waypoints[i].HeartRate);
              }

              var attributes = new List<WaypointAttribute>
                         {
                           WaypointAttribute.Pace,
                           WaypointAttribute.HeartRate,
                           WaypointAttribute.Altitude,
                           WaypointAttribute.Speed,
                           WaypointAttribute.DirectionDeviationToNextLap,
                           WaypointAttribute.ElapsedTime,
                           WaypointAttribute.Distance,
                           WaypointAttribute.Inclination,
                           WaypointAttribute.Direction,
                           WaypointAttribute.Longitude,
                           WaypointAttribute.Latitude,
                           WaypointAttribute.Cadence,
                           WaypointAttribute.Power
                         };

              // map reading
              if(waypointAttributeExists[WaypointAttribute.MapReadingDuration])
              {
            if(parameterizedLocation.IsNode)
            {
              w.MapReadingState = waypoints[i].MapReadingState;
            }
            else
            {
              w.MapReadingState = waypoints[i].MapReadingState == MapReadingState.NotReading || waypoints[i + 1].MapReadingState == MapReadingState.NotReading
            ? MapReadingState.NotReading
            : MapReadingState.Reading;
            }
            attributes.AddRange(new[]
                              {
                                WaypointAttribute.MapReadingDuration,
                                WaypointAttribute.MapReadingState,
                                WaypointAttribute.PreviousMapReadingEnd,
                                WaypointAttribute.NextMapReadingStart,
                              });
              }

              foreach (var attribute in attributes)
              {
            w.Attributes[attribute] = GetAttributeValueBetweenWaypoints(waypoints[i], waypoints[i + 1], d, attribute);
              }

              return w;
        }
Ejemplo n.º 12
0
 public Waypoint Clone()
 {
     var newWaypoint = new Waypoint(time, longLat, altitude, heartRate, mapReadingState, cadence, power);
       foreach (var attributeKey in Attributes.Keys)
       {
     newWaypoint.Attributes[attributeKey] = Attributes[attributeKey];
       }
       return newWaypoint;
 }
Ejemplo n.º 13
0
 // w0 and w1 are adjacent, t measured from w0
 private static double? GetAttributeValueBetweenWaypoints(Waypoint w0, Waypoint w1, double t, WaypointAttribute attribute)
 {
     switch(attribute)
       {
     case WaypointAttribute.MapReadingDuration:
       return w0.MapReadingState == MapReadingState.StartReading || w0.MapReadingState == MapReadingState.Reading
     ? w0.Attributes[WaypointAttribute.MapReadingDuration]
     : null;
     case WaypointAttribute.MapReadingState:
       return GetAttributeValueBetweenWaypoints(w0, w1, t, WaypointAttribute.MapReadingDuration) != null ? 1 : 0;
     case WaypointAttribute.PreviousMapReadingEnd:
       return w1.Attributes[WaypointAttribute.PreviousMapReadingEnd] != null
       ? (double?)(w1.Attributes[WaypointAttribute.PreviousMapReadingEnd].Value - (1 - t) * (w1.Time - w0.Time).TotalSeconds)
       : null;
     case WaypointAttribute.NextMapReadingStart:
       return w0.Attributes[WaypointAttribute.NextMapReadingStart] != null
       ? (double?)(w0.Attributes[WaypointAttribute.NextMapReadingStart].Value - t * (w1.Time - w0.Time).TotalSeconds)
       : null;
     default:
       if (w0.Attributes.ContainsKey(attribute) && w1.Attributes.ContainsKey(attribute))
       {
     var d0 = w0.Attributes[attribute];
     var d1 = w1.Attributes[attribute];
     if (d0.HasValue && d1.HasValue) return d0 + t * (d1 - d0);
     if (!d0.HasValue && !d1.HasValue) return null;
     return (t < 0.5 ? d0 : d1);
       }
       return null;
       }
 }