internal static void setCapacity(IDistanceDataTrack t, int v) { #if ST_3_1_5314 if (t is ZoneFiveSoftware.Common.Data.DistanceDataTrack2) { ((ZoneFiveSoftware.Common.Data.DistanceDataTrack2)t).Capacity = v; } #endif }
private bool FillSingleDataSerie(LineChartTypes chartType, ChartDataSeries dataSerie) { INumericTimeDataSeries graphPoints = GetSmoothedActivityTrack(chartType); if (graphPoints.Count > 0) { TimeSpan trackStartDiffWithActivity = graphPoints.StartTime - m_ActivityInfoCache.ActualTrackStart; float trackSecondDifference = (float)trackStartDiffWithActivity.TotalSeconds; if (XAxisReferential == XAxisValue.Time) { graphPoints = Utils.Utils.RemovePausedTimesInTrack(graphPoints, Activity); foreach (ITimeValueEntry <float> entry in graphPoints) { float key = trackSecondDifference + entry.ElapsedSeconds; if (!dataSerie.Points.ContainsKey(key)) { dataSerie.Points.Add(key, new PointF(trackSecondDifference + entry.ElapsedSeconds, entry.Value)); } } } else if (m_ActivityInfoCache.MovingDistanceMetersTrack != null) { IDistanceDataTrack distanceTrack = m_ActivityInfoCache.MovingDistanceMetersTrack; int pointCount = Math.Min(distanceTrack.Count, graphPoints.Count); ITimeValueEntry <float> startEntry = distanceTrack.GetInterpolatedValue(graphPoints.StartTime); foreach (ITimeValueEntry <float> entry in graphPoints) { ITimeValueEntry <float> interpolatedEntry = distanceTrack.GetInterpolatedValue(graphPoints.StartTime + new TimeSpan(0, 0, (int)entry.ElapsedSeconds)); if (interpolatedEntry != null) { float distanceAtTime = interpolatedEntry.Value; float distanceValue = (float)Length.Convert(distanceAtTime, Length.Units.Meter, Activity.Category.DistanceUnits); float key = trackSecondDifference + entry.ElapsedSeconds; if (!dataSerie.Points.ContainsKey(key)) { dataSerie.Points.Add(key, new PointF(distanceValue, entry.Value)); } } } } return(true); } return(false); }
/// <summary> /// Populate a dataseries with data from a NumericTimeDataSeries /// </summary> /// <param name="timeDataSeries">NumericTimeDataSeries containing data to add to chart data series</param> /// <param name="chartDataSeries">Dataseries to add data to</param> /// <param name="chartType">Chart basis (time or distance)</param> /// <returns>Populated dataseries</returns> private static ChartDataSeries PopulateDataSeries(INumericTimeDataSeries timeDataSeries, ChartDataSeries chartDataSeries, ChartBasis chartType, IActivity activity) { switch (chartType) { case ChartBasis.Gear_Distance: ActivityInfo info = ActivityInfoCache.Instance.GetInfo(activity); IDistanceDataTrack track = GearUtils.GetDistanceTrack(activity); float test = 0; foreach (ITimeValueEntry <float> entry in timeDataSeries) { DateTime time = track.EntryDateTime(entry); float distance = track.GetInterpolatedValue(time).Value; distance = (float)Length.Convert(distance, Length.Units.Meter, activity.Category.DistanceUnits); PointF point = new PointF(distance, entry.Value); if (!chartDataSeries.Points.ContainsKey(point.X)) { chartDataSeries.Points.Add(point.X, point); } else if (test != point.X) { test = point.X; } } break; case ChartBasis.Gear_Time: foreach (ITimeValueEntry <float> entry in timeDataSeries) { PointF point = new PointF(entry.ElapsedSeconds, entry.Value); chartDataSeries.Points.Add(point.X, point); } break; default: break; } return(chartDataSeries); }
/******************************************************/ public static DateTime getDateTimeFromTrackDist(IDistanceDataTrack distTrack, float t) { DateTime res = DateTime.MinValue; if (t >= distTrack.Max && distTrack.Count > 0) { res = distTrack.StartTime.AddSeconds(distTrack.TotalElapsedSeconds); } else if (t <= distTrack.Min) { res = distTrack.StartTime; } else { try { res = distTrack.GetTimeAtDistanceMeters(t); } catch { } } return(res); }
internal DistanceDataTrack(IDistanceDataTrack d) : base(d) { }
public static TrailResultInfo TrailResultInfoFromSplits(IActivity activity, bool onlyActiveLaps) { TrailResultInfo results = new TrailResultInfo(activity, false); if (activity == null) { //summary result return(results); } //Get around a problem with only Rest laps if (onlyActiveLaps) { onlyActiveLaps = false; for (int j = 0; j < activity.Laps.Count; j++) { if (!activity.Laps[j].Rest) { onlyActiveLaps = true; break; } } } bool lastIsRestlap = false; if (null == activity.Laps || 0 == activity.Laps.Count) { //Use MovingDistanceMetersTrack rather than ActualDistanceMetersTrack, assume similar activities have similar pauses/slow parts IDistanceDataTrack track = ActivityInfoCache.Instance.GetInfo(activity).MovingDistanceMetersTrack; if (track != null && track.Max > 0) { //Create some kind of points - could be dependent on length const float cDist = 1000; float dist = 0; while (dist < track.Max) { DateTime time = track.GetTimeAtDistanceMeters(dist); IGPSPoint p = Utils.TrackUtil.getGpsLoc(activity, time); if (p != null) { results.Points.Add(new TrailResultPoint(new TrailGPSLocation(p), time)); } else { if (activity.GPSRoute == null || activity.GPSRoute.Count == 0) { results.Points.Add(new TrailResultPoint(new TrailGPSLocation(activity.Name, true), time, track.TotalElapsedSeconds)); } else { System.Diagnostics.Debug.Assert(false, "out of GPS"); if (results.Points.Count > 0) { //end insert break; } } } dist = Math.Min(track.Max, dist + cDist); } } else { DateTime time = ActivityInfoCache.Instance.GetInfo(activity).ActualTrackStart; IGPSPoint p = Utils.TrackUtil.getGpsLoc(activity, time); if (p != null) { results.Points.Add(new TrailResultPoint(new TrailGPSLocation(p), time)); } } } else { int subresultIndex = 1; for (int j = 0; j < activity.Laps.Count; j++) { ILapInfo l = activity.Laps[j]; if (!onlyActiveLaps || !l.Rest || j > 0 && !activity.Laps[j - 1].Rest) { string name = l.Notes; if (string.IsNullOrEmpty(name)) { name = "#" + (results.Points.Count + 1); } DateTime d = l.StartTime; if (activity.GPSRoute == null || activity.GPSRoute.Count == 0) { results.Points.Add(new TrailResultPoint(new TrailGPSLocation(name, !l.Rest), d, l.TotalTime, l)); } else { IGPSPoint t = Utils.TrackUtil.getGpsLoc(activity, d); if (t != null) { results.Points.Add(new TrailResultPoint(new TrailGPSLocation(t, name, !l.Rest), d, l.TotalTime, l)); } } if (//All swim related have at least one PoolLength for each lap l.PoolLengths != null && (l.PoolLengths.Count > 0)) { TrailResultPoint tp = results.Points[results.Points.Count - 1]; foreach (IPoolLengthInfo p in l.PoolLengths) { DateTime d2 = p.StartTime; IPoolLengthInfo p1 = PoolLengthInfo.GetPoolLength(p); tp.SubPoints.Add(new TrailResultPoint(new TrailGPSLocation(null, !l.Rest), d2, p.TotalTime, p1, subresultIndex++)); } //Need (dummy) last point IPoolLengthInfo p2 = tp.SubPoints[tp.SubPoints.Count - 1].PoolLengthInfo; tp.SubPoints.Add(new TrailResultPoint(new TrailGPSLocation(null, !l.Rest), p2.StartTime + p2.TotalTime, TimeSpan.Zero, p2, subresultIndex)); } } } lastIsRestlap = activity.Laps[activity.Laps.Count - 1].Rest; } //Add end point, except if last is a rest lap (where last already is added) if (!onlyActiveLaps || !lastIsRestlap) { DateTime d = ActivityInfoCache.Instance.GetInfo(activity).ActualTrackEnd; if (activity.GPSRoute == null || activity.GPSRoute.Count == 0) { results.Points.Add(new TrailResultPoint(new TrailGPSLocation(activity.Name, !lastIsRestlap), d)); } else { IGPSPoint t = Utils.TrackUtil.getGpsLoc(activity, d); if (t != null) { results.Points.Add(new TrailResultPoint(new TrailGPSLocation(t, activity.Name, !lastIsRestlap), d)); } } } //Special for activities without any GPS info if (results.Count == 0 && activity.HasStartTime) { results.Points.Add(new TrailResultPoint(new TrailGPSLocation(activity.Name, true), activity.StartTime)); results.Points.Add(new TrailResultPoint(new TrailGPSLocation(activity.Name, true), activity.StartTime + activity.TotalTimeEntered)); } //A trail created from splits should not define elevation points foreach (TrailGPSLocation t in results.Points) { t.SetElevation(float.NaN); } return(results); }
public GPSGrid(GPSGrid refGrid, IGPSRoute route, double BWidthFactor, double DistFactor, bool isDist) { m_Distance = DistFactor * Settings.Radius; m_Grid = new Dictionary<int, IDictionary<int, IList<int>>>(); m_Route = route; //Just copy the reference if (refGrid == null) { //Set grid size from aprox distance for reference //See Trails plugin, TrailsGPSLocation.getGPSBounds() m_latWidth = BWidthFactor * Settings.Radius / 110574 * 1.005F; m_lngWidth = BWidthFactor * Settings.Radius / 111132 / Math.Cos(m_Route[0].Value.LongitudeDegrees * Math.PI / 180); } else { m_latWidth = refGrid.m_latWidth; m_lngWidth = refGrid.m_lngWidth; } if (isDist) { m_Dist = m_Route.GetDistanceMetersTrack(); } else { m_Dist = null; } for (int i = 0; i < m_Route.Count; i++ ) { addGrid(i); } }
/// <summary> /// Used to generate the record properties of the supplied activity /// </summary> /// <param name="activity">The full activity for the record</param> /// <param name="category">The Record Category for this record</param> /// <param name="gpsTrack">The GPS route of the actual record</param> /// <param name="hrTrack">The HR track of the actual record</param> /// <param name="pwrTrack">The power track of the actual record</param> /// <param name="cadTrack">The cadence track of the actual record</param> public Record(IActivity activity, RecordCategory category, IGPSRoute gpsTrack, INumericTimeDataSeries hrTrack, INumericTimeDataSeries pwrTrack, INumericTimeDataSeries cadTrack, IDistanceDataTrack distTrack, INumericTimeDataSeries elevTrack, DateTime activityStartTime) { // Create new activity from template IActivity recActivity = (IActivity)Activator.CreateInstance(activity.GetType()); // HACK: Manually Clone 'activity' until a better way is found recActivity.Category = activity.Category; recActivity.DistanceMetersTrack = distTrack; recActivity.ElevationMetersTrack = elevTrack; recActivity.GPSRoute = gpsTrack; recActivity.HasStartTime = activity.HasStartTime; recActivity.HeartRatePerMinuteTrack = hrTrack; recActivity.Intensity = activity.Intensity; recActivity.Location = activity.Location; recActivity.Name = activity.Name; recActivity.PowerWattsTrack = pwrTrack; recActivity.CadencePerMinuteTrack = cadTrack; recActivity.Weather.Conditions = activity.Weather.Conditions; recActivity.Weather.CurentDirectionDegrees = activity.Weather.CurentDirectionDegrees; recActivity.Weather.CurentSpeedKilometersPerHour = activity.Weather.CurentSpeedKilometersPerHour; recActivity.Weather.HumidityPercent = activity.Weather.HumidityPercent; recActivity.Weather.TemperatureCelsius = activity.Weather.TemperatureCelsius; recActivity.Weather.WindDirectionDegrees = activity.Weather.WindDirectionDegrees; recActivity.Weather.WindSpeedKilometersPerHour = activity.Weather.WindSpeedKilometersPerHour; // Set the start time for the record activity recActivity.StartTime = activityStartTime; // Set up the activity info for pulling summary data ActivityInfo info = ActivityInfoCache.Instance.GetInfo(recActivity); // Set the record category this.category = category; // Max and Min elevation seen over the route float maxE = float.NegativeInfinity; float minE = float.PositiveInfinity; if (activity.GPSRoute != null && activity.GPSRoute.Count > 0) { GPSRoute startRoute = new GPSRoute(); for (int i = 0; i < activity.GPSRoute.Count; i++) { GPSPoint p = (GPSPoint)activity.GPSRoute[i].Value; if (p.ElevationMeters > maxE) { maxE = p.ElevationMeters; } if (p.ElevationMeters < minE) { minE = p.ElevationMeters; } if (gpsTrack.Count == 0) { break; } if (p.Equals((GPSPoint)gpsTrack[0].Value)) { break; } else { startRoute.Add(activity.GPSRoute.EntryDateTime(activity.GPSRoute[i]), p); } } startDistance = startRoute.TotalDistanceMeters; } else if (activity.ElevationMetersTrack != null) { for (int i = 0; i < activity.ElevationMetersTrack.Count; i++) { if (activity.ElevationMetersTrack[i].Value > maxE) { maxE = activity.ElevationMetersTrack[i].Value; } if (activity.ElevationMetersTrack[i].Value < maxE) { minE = activity.ElevationMetersTrack[i].Value; } } startDistance = 0; } this.maxElevation = maxE; this.minElevation = minE; this.trueStartDate = activity.StartTime; this.activity = recActivity; }
private static IList <IItemTrackSelectionInfo> SetAndAdjustFromSelection (IList <IItemTrackSelectionInfo> selected, IEnumerable <IActivity> activities, bool fromST) { if (selected == null || selected.Count == 0 || activities == null) { //Do not adjust selection return(selected); } bool singleSelection = selected.Count == 0 || selected.Count == 1 && !( selected[0].MarkedDistances != null && selected[0].MarkedDistances.Count > 1 || selected[0].MarkedTimes != null && selected[0].MarkedTimes.Count > 1); IList <IItemTrackSelectionInfo> results = new List <IItemTrackSelectionInfo>(); foreach (IItemTrackSelectionInfo sel in selected) { IActivity activity = null; if (sel is TrailsItemTrackSelectionInfo) { activity = ((TrailsItemTrackSelectionInfo)sel).Activity; } else { if (activities == null) { if (UnitUtil.GetApplication() == null || UnitUtil.GetApplication().Logbook == null) { activities = new List <IActivity>(); } else { activities = UnitUtil.GetApplication().Logbook.Activities; } } foreach (IActivity a in activities) { //In ST3.0.4068 (at least) only one activity is selected if (a != null && sel.ItemReferenceId == a.ReferenceId) { activity = a; break; } } } if (activity != null) { //The distance is in unstopped/unpaused format IDistanceDataTrack activityUnpausedDistanceMetersTrack = ActivityInfoCache.Instance.GetInfo(activity).ActualDistanceMetersTrack; TrailsItemTrackSelectionInfo tmpSel = new TrailsItemTrackSelectionInfo(); tmpSel.SetFromSelection(sel, activity); if (fromST) { //Set MarkedTimes (or SelectedTime), used internally. No need to clear "unused" if (sel.MarkedDistances != null && sel.MarkedDistances.Count > 0 && (sel.MarkedTimes == null || sel.MarkedTimes.Count == 0)) { try { foreach (ValueRange <double> t in sel.MarkedDistances) { DateTime d1 = activityUnpausedDistanceMetersTrack.GetTimeAtDistanceMeters(t.Lower); DateTime d2 = activityUnpausedDistanceMetersTrack.GetTimeAtDistanceMeters(t.Upper); AddMarkedOrSelectedTime(tmpSel, singleSelection, d1, d2); } tmpSel.MarkedDistances = null; } catch { } } if (sel.SelectedTime != null && sel.MarkedTimes == null) { try { AddMarkedOrSelectedTime(tmpSel, singleSelection, sel.SelectedTime.Lower, sel.SelectedTime.Upper); //tmpSel.SelectedTime = null; } catch { } } if (sel.SelectedDistance != null && sel.MarkedTimes == null) { tmpSel.MarkedTimes = new ValueRangeSeries <DateTime>(); try { DateTime d1 = activityUnpausedDistanceMetersTrack.GetTimeAtDistanceMeters(sel.SelectedDistance.Lower); DateTime d2 = activityUnpausedDistanceMetersTrack.GetTimeAtDistanceMeters(sel.SelectedDistance.Upper); AddMarkedOrSelectedTime(tmpSel, singleSelection, d1, d2); tmpSel.SelectedDistance = null; } catch { } } } else { //To ST //The standard in the plugin(time) to standard in ST core and omb's Track Coloring (unpaused distance) if (sel.MarkedDistances == null && sel.MarkedTimes != null && sel.MarkedTimes.Count > 0) { try { tmpSel.MarkedDistances = new ValueRangeSeries <double>(); foreach (ValueRange <DateTime> t in sel.MarkedTimes) { //If real time differs with a couple of seconds, use that const int maxTimeDiff = 2; DateTime start = t.Lower; if (start < activityUnpausedDistanceMetersTrack.StartTime && start > activityUnpausedDistanceMetersTrack.StartTime - TimeSpan.FromSeconds(maxTimeDiff)) { start = activityUnpausedDistanceMetersTrack.StartTime; } DateTime end = t.Upper; if (end > activityUnpausedDistanceMetersTrack.StartTime + TimeSpan.FromSeconds(activityUnpausedDistanceMetersTrack.TotalElapsedSeconds) && end < activityUnpausedDistanceMetersTrack.StartTime + TimeSpan.FromSeconds(activityUnpausedDistanceMetersTrack.TotalElapsedSeconds - maxTimeDiff)) { end = activityUnpausedDistanceMetersTrack.StartTime + TimeSpan.FromSeconds(activityUnpausedDistanceMetersTrack.TotalElapsedSeconds); } double d1 = activityUnpausedDistanceMetersTrack.GetInterpolatedValue(start).Value; double d2 = activityUnpausedDistanceMetersTrack.GetInterpolatedValue(end).Value; AddMarkedOrSelectedDistance(tmpSel, singleSelection, d1, d2); } tmpSel.MarkedTimes = null; } catch { } } if (sel.SelectedDistance == null && sel.SelectedTime != null) { try { tmpSel.SelectedDistance = new ValueRange <double>( activityUnpausedDistanceMetersTrack.GetInterpolatedValue(sel.SelectedTime.Lower).Value, activityUnpausedDistanceMetersTrack.GetInterpolatedValue(sel.SelectedTime.Upper).Value); tmpSel.SelectedTime = null; } catch { } } } results.Add(tmpSel); } } return(results); }