public void UpdateIndexes(TrailResultInfo indexes)
{
this.Children.Clear();
this.m_allChildren.Clear();
this.Result.UpdateIndexes(indexes);
this.GetChildren();
}
protected ChildTrailResult(ChildTrailResult cpar, int order, TrailResultInfo indexes) :
base(cpar.ActivityTrail, order, indexes, 0)
{
UpdateIndexes(indexes);
//Let this point to main parent, no ref to (parent) child (can be derived too)
this.m_parentResult = cpar.ParentResult;
}
private void addPausesAsResults(IList <ChildTrailResult> splits, int lastNormalSplit, ICollection <IValueRange <DateTime> > pauses, PauseType pauseType)
{
foreach (IValueRange <DateTime> v in pauses)
{
//Pauses could extend outside the borders
DateTime lower = v.Lower;
if (lower == DateTime.MinValue)
{
lower = m_subResultInfo.Points[0].Time;
}
DateTime upper = v.Upper;
if (upper == DateTime.MaxValue)
{
upper = m_subResultInfo.Points[m_subResultInfo.Points.Count - 1].Time;
}
//skip very short pauses
TimeSpan duration = upper - lower;
if (duration < TimeSpan.FromSeconds(1) &&
(this.StartTime - lower < TimeSpan.FromSeconds(1) ||
upper - this.EndTime < TimeSpan.FromSeconds(1)))
{
continue;
}
//Match the pause to a split
for (int j = 0; j <= lastNormalSplit; j++)
{
if (splits[j].m_subResultInfo.Points[0].Time > DateTime.MinValue &&
splits[j].m_subResultInfo.Points[1].Time > DateTime.MinValue &&
//pause is started within this split
(splits[j].m_subResultInfo.Points[0].Time <= lower && lower <= splits[j].m_subResultInfo.Points[1].Time ||
//(First) lap, ends in the split
/*splits[j].*/ m_subResultInfo.Points[0].Time <= upper && upper < splits[j].m_subResultInfo.Points[1].Time ||
//For splits we want pauses also before after first normal split
this.Trail.IsSplits && (
upper < splits[j].m_subResultInfo.Points[0].Time ||
j == lastNormalSplit && splits[j].m_subResultInfo.Points[1].Time < lower)))
{
TrailResultInfo t = new TrailResultInfo(this.m_subResultInfo.Activity, this.m_subResultInfo.Reverse);
TrailGPSLocation tl = new TrailGPSLocation(PausedChildTrailResult.PauseName(pauseType), false);
t.Points.Add(new TrailResultPoint(tl, lower, duration));
t.Points.Add(new TrailResultPoint(tl, upper, TimeSpan.Zero));
PausedChildTrailResult tr = new PausedChildTrailResult(this, splits[j], -1, t, pauseType);
if (pauseType == PauseType.RestLap)
{
if (this.m_lapPauseMapping.ContainsKey(v))
{
tr.m_LapInfo = this.m_lapPauseMapping[v];
}
}
splits.Add(tr);
break;
}
}
}
}
//Handle the points as a child result - promote info
public TrailResultInfo CopyToChild(int i, int j)
{
TrailResultInfo result = new TrailResultInfo(this.Activity, this.Reverse);
result.Points.Add(new TrailResultPoint(this.Points[i]));
result.Points.Add(new TrailResultPoint(this.Points[j]));
//Point 0 lap data applies to this result (PoolLengthInfo is extracted from point 0)
result.LapInfo = this.Points[i].LapInfo;
return(result);
}
public static IList <TrailGPSLocation> TrailGpsPointsFromSplits(IActivity activity, bool onlyActiveLaps)
{
TrailResultInfo info = TrailResultInfoFromSplits(activity, onlyActiveLaps);
IList <TrailGPSLocation> result = new List <TrailGPSLocation>();
foreach (TrailResultPoint t in info.Points)
{
result.Add(t);
}
return(result);
}
//Hide the handling slightly
public TrailResultInfo Copy()
{
TrailResultInfo result = new TrailResultInfo(this.Activity, this.Reverse);
result.m_DistDiff = this.m_DistDiff;
result.LapInfo = this.LapInfo;
foreach (TrailResultPoint p in Points)
{
result.Points.Add(p);
}
return(result);
}
public int CompareTo(object obj)
{
if (obj is TrailResultInfo)
{
TrailResultInfo t = obj as TrailResultInfo;
if (this.DistDiff == t.DistDiff)
{
return(0);
}
return(this.DistDiff < t.DistDiff ? -1 : 1);
}
return(-1);
}
static public TrailResultInfo ResultInfoFromSelection(IActivity activity, ZoneFiveSoftware.Common.Visuals.Fitness.IItemTrackSelectionInfo selInfo)
{
TrailResultInfo indexes = new TrailResultInfo(activity, false);
DateTime time = selInfo.MarkedTimes[0].Lower;
IGPSPoint p = Utils.TrackUtil.getGpsLoc(activity, time);
if (p != null)
{
indexes.Points.Add(new TrailResultPoint(new TrailGPSLocation(p), time));
}
time = selInfo.MarkedTimes[0].Upper;
p = Utils.TrackUtil.getGpsLoc(activity, time);
if (p != null)
{
indexes.Points.Add(new TrailResultPoint(new TrailGPSLocation(p), time));
}
return(indexes);
}
public TrailResultInfo CopyFromReference(IActivity activity)
{
TrailResultInfo result = new TrailResultInfo(activity, this.Reverse);
foreach (TrailResultPoint p in Points)
{
TrailGPSLocation loc;
ZoneFiveSoftware.Common.Data.GPS.IGPSPoint t = Utils.TrackUtil.getGpsLoc(activity, p.Time);
if (t != null)
{
loc = new TrailGPSLocation(t, p.Name, p.Required);
}
else
{
loc = new TrailGPSLocation(p.Name, p.Required);
}
TrailResultPoint p2 = new TrailResultPoint(p, loc);
p2.LapInfo = null;
p2.PoolLengthInfo = null;
result.Points.Add(p2);
}
return(result);
}
public IList <ChildTrailResult> getChildren()
{
IList <ChildTrailResult> splits = new List <ChildTrailResult>();
if (this.m_subResultInfo.Count > 1)
{
int i; //start time index
int subChildIndex = 1; //Swim sub index
for (i = 0; i < m_subResultInfo.Count - 1; i++)
{
if (m_subResultInfo.Points[i].Time != DateTime.MinValue &&
(m_subResultInfo.Points[i].Required || !Data.Settings.NonReqIsPause))
{
int j; //end time index
for (j = i + 1; j < m_subResultInfo.Points.Count; j++)
{
if (m_subResultInfo.Points[j].Time != DateTime.MinValue)
{
break;
}
}
if (this.m_subResultInfo.Count > i &&
this.m_subResultInfo.Count > j)
{
if (m_subResultInfo.Points[j].Time != DateTime.MinValue)
{
TrailResultInfo indexes = m_subResultInfo.CopyToChild(i, j);
int childIndex = i + 1;
if (m_subResultInfo.Points[i].Order >= 0)
{
childIndex = m_subResultInfo.Points[i].Order;
}
ChildTrailResult ctr = new NormalChildTrailResult(this, childIndex, indexes);
//Note: paused results may be added, no limit for childresults
TimeSpan duration = ZoneFiveSoftware.Common.Data.Algorithm.DateTimeRangeSeries.TimeNotPaused(ctr.StartTime, ctr.EndTime, this.Pauses);
if (duration > TimeSpan.FromSeconds(3) && this.OverlapRef == null ||
duration > TimeSpan.FromSeconds(20))
{
splits.Add(ctr);
if (m_subResultInfo.Points[i].SubPoints.Count > 1)
{
TrailResultInfo indexes2 = m_subResultInfo.Copy();
for (int k = 0; k < m_subResultInfo.Points[i].SubPoints.Count - 1; k++)
{
indexes2.Points.Clear();
indexes2.Points.Add(m_subResultInfo.Points[i].SubPoints[k]);
indexes2.Points.Add(m_subResultInfo.Points[i].SubPoints[k + 1]);
ChildTrailResult sub = new SubChildTrailResult(ctr, subChildIndex++, indexes2);
}
}
}
}
}
i = j - 1;//Next index to try
}
}
if (Data.Settings.ShowPausesAsResults)
{
int lastNormalSplit = -1;
for (int j = 0; j < splits.Count; j++)
{
if (splits[j] is PausedChildTrailResult)
{
//All normal splits checked
break;
}
lastNormalSplit = j;
}
addPausesAsResults(splits, lastNormalSplit, this.TimerPauses, PauseType.Timer);
addPausesAsResults(splits, lastNormalSplit, this.LapPauses, PauseType.RestLap);
addPausesAsResults(splits, lastNormalSplit, this.NonRequiredPauses, PauseType.NonReqPoint);
addPausesAsResults(splits, lastNormalSplit, this.StoppedPauses, PauseType.Stopped);
}
TimeSpan sp = TimeSpan.Zero;
bool ok = true;
foreach (ChildTrailResult ctr in splits)
{
if (ctr.DurationIsNull())
{
ok = false;
break;
}
if (!(ctr is PausedChildTrailResult))
{
sp = sp.Add(ctr.Duration);
}
}
if (ok)
{
this.m_duration = sp;
}
}
//Only one subresult is not shown, add pool length to main result
if (splits.Count <= 1 && this.SubResultInfo.Points.Count > 0)
{
this.m_PoolLengthInfo = this.SubResultInfo.Points[0].PoolLengthInfo;
}
return(splits);
}
protected ParentTrailResult(ActivityTrail activityTrail, int order, TrailResultInfo indexes, float distDiff) :
base(activityTrail, order, indexes, distDiff)
{
}
public HighScoreParentTrailResult(ActivityTrail activityTrail, int order, TrailResultInfo indexes, string toolTip)
: base(activityTrail, order, indexes, 0)
{
this.m_toolTip = toolTip;
this.UpdateIndexes(indexes);
}
public SplitsParentTrailResult(ActivityTrail activityTrail, int order, TrailResultInfo indexes) :
base(activityTrail, order, indexes, 0)
{
this.UpdateIndexes(indexes);
}
//Normal TrailResult
public PositionParentTrailResult(ActivityTrail activityTrail, int order, TrailResultInfo indexes, float distDiff, bool reverse)
: base(activityTrail, order, indexes, distDiff)
{
this.m_reverse = reverse;
this.UpdateIndexes(indexes);
}
public PausedChildTrailResult(ParentTrailResult par, ChildTrailResult ctr, int order, TrailResultInfo indexes, PauseType pauseType) :
base(par, order, indexes, 0)
{
this.RelatedChildResult = ctr;
this.pauseType = pauseType;
}
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 SubChildTrailResult(ChildTrailResult par, int order, TrailResultInfo indexes) :
base(par, order, indexes)
{
par.SubResults.Add(this);
}
public NormalChildTrailResult(ParentTrailResult par, int order, TrailResultInfo indexes) :
base(par, order, indexes, indexes.DistDiff)
{
}
public HighScoreChildTrailResult(HighScoreParentTrailResult par, int order, TrailResultInfo indexes, string tt) :
base(par, order, indexes, 0)
{
this.m_toolTip = tt;
this.PartOfParent = false;
}
protected ChildTrailResult(ParentTrailResult par, int order, TrailResultInfo indexes, float distDiff) :
base(par.ActivityTrail, order, indexes, distDiff)
{
UpdateIndexes(indexes);
this.m_parentResult = par;
}
