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);
}
