/***************************************************/
internal static void removePause(IValueRangeSeries <DateTime> pauses, DateTime startTime, DateTime endTime)
{
for (int i = 0; i < pauses.Count;)
{
IValueRange <DateTime> t = pauses[i];
if (t.Lower < startTime && startTime <= t.Upper)
{
pauses.RemoveAt(i);
if (endTime < t.Upper)
{
IValueRange <DateTime> t2 = new ValueRange <DateTime>(endTime, t.Upper);
pauses.Add(t2);
}
}
else if (t.Lower < endTime && endTime <= t.Upper)
{
pauses.RemoveAt(i);
IValueRange <DateTime> t2 = new ValueRange <DateTime>(startTime, t.Lower);
pauses.Add(t2);
}
else
{
i++;
}
}
}
public InsertValues(DateTime startTime, DateTime endTime, IValueRangeSeries <DateTime> pauses)
{
this.startTime = startTime;
this.endTime = endTime;
this.pauses = pauses;
this.points = null;
}
//Exclude the pauses from the selection
public static IValueRangeSeries <DateTime> excludePauses(IValueRangeSeries <DateTime> sels, IValueRangeSeries <DateTime> pauses)
{
IValueRangeSeries <DateTime> t = new ValueRangeSeries <DateTime>();
foreach (IValueRange <DateTime> tsel in sels)
{
foreach (IValueRange <DateTime> t1 in DateTimeRangeSeries.TimesNotPaused(
tsel.Lower, tsel.Upper, pauses))
{
t.Add(t1);
}
}
return(t);
}
public static IList <IList <IGPSPoint> > GpsPoints(IGPSRoute gpsRoute, IValueRangeSeries <DateTime> selections)
{
IList <IList <IGPSPoint> > result = new List <IList <IGPSPoint> >();
if (selections != null && selections.Count > 0 && gpsRoute != null && gpsRoute.Count > 1)
{
//selection and gps points are sorted without overlap so traverse over gps points only once
//(previous version had much more complicated version, that also accounted for pauses)
int i = 0;
foreach (IValueRange <DateTime> sel in selections)
{
IList <IGPSPoint> track = new List <IGPSPoint>();
//Use start/end "with priority", even if extra points are added. Care needed if returning GPSRoute
DateTime t = DateTimeRangeSeries.Latest(sel.Lower, gpsRoute.StartTime);
ITimeValueEntry <IGPSPoint> pt = gpsRoute.GetInterpolatedValue(t);
if (pt != null)
{
track.Add(pt.Value);
}
while (i < gpsRoute.Count)
{
ITimeValueEntry <IGPSPoint> entry = gpsRoute[i];
DateTime time = gpsRoute.EntryDateTime(entry);
i++;
if (sel.Lower > time)
{
continue;
}
if (sel.Upper < time)
{
//Do not increase counter here, it could be needed
i--;
break;
}
track.Add(entry.Value);
}
t = DateTimeRangeSeries.Earliest(sel.Upper, gpsRoute.StartTime.AddSeconds(gpsRoute.TotalElapsedSeconds));
pt = gpsRoute.GetInterpolatedValue(t);
if (pt != null)
{
track.Add(pt.Value);
}
result.Add(track);
}
}
return(result);
}
//ST IsPaused reports no pause if time matches, this also checks borders
private static bool IsPause(DateTime time, IValueRangeSeries <DateTime> pauses)
{
bool res = DateTimeRangeSeries.IsPaused(time, pauses);
if (!res)
{
foreach (IValueRange <DateTime> pause in pauses)
{
if (time.CompareTo(pause.Lower) >= 0 &&
time.CompareTo(pause.Upper) <= 0)
{
res = true;
break;
}
}
}
return(res);
}
public Result(Goal goal, IActivity activity, IValueRangeSeries<DateTime> pause,
double domainStart, double domainEnd,
double timeStart, double timeEnd, double meterStart, double meterEnd, double elevationStart,
double elevationEnd, DateTime firstDate, DateTime endDate)
{
this.Goal = goal;
this.DomainDiff = domainEnd - domainStart;
this.Activity = activity;
this.pause = pause;
//this.TimeStart = timeStart;
//this.TimeEnd = timeEnd;
this.Seconds = timeEnd - timeStart;
//this.MeterStart = meterStart;
//this.MeterEnd = meterEnd;
this.Meters = meterEnd - meterStart;
//this.ElevationStart = elevationStart;
//this.ElevationEnd = elevationEnd;
this.Elevations = elevationEnd - elevationStart;
this.DateStart = firstDate;
this.DateEnd = endDate;
}
public TrailResultMarked(TrailResult tr, IValueRangeSeries <DateTime> t)
{
this.trailResult = tr;
this.selInfo.MarkedTimes = TrailsItemTrackSelectionInfo.excludePauses(t, tr.Pauses);
this.selInfo.Activity = tr.Activity;
}
internal static DateTime getFirstUnpausedTime(DateTime dateTime, bool isPause, IValueRangeSeries <DateTime> pauses, bool next)
{
if (isPause)
{
foreach (IValueRange <DateTime> pause in pauses)
{
if (dateTime.CompareTo(pause.Lower) >= 0 &&
dateTime.CompareTo(pause.Upper) <= 0)
{
if (next)
{
dateTime = (pause.Upper);//.Add(TimeSpan.FromSeconds(1));
}
else if (pause.Lower > DateTime.MinValue)
{
dateTime = (pause.Lower);//.Add(TimeSpan.FromSeconds(-1));
}
break;
}
}
}
return(dateTime);
}
internal static DateTime getFirstUnpausedTime(DateTime dateTime, IValueRangeSeries <DateTime> pauses, bool next)
{
return(getFirstUnpausedTime(dateTime, ZoneFiveSoftware.Common.Data.Algorithm.DateTimeRangeSeries.IsPaused(dateTime, pauses), pauses, next));
}
private static void calculateActivity(IActivity activity, IValueRangeSeries<DateTime> pause, IList<Goal> goals, SortedList<Result, Result>[] results)
{
ActInfo act = new ActInfo(activity, pause, goals);
foreach (Goal goal in goals)
{
Result result = null;
if (Goal.IsZoneGoal(goal.Image))
{
if (act.ZoneOk(goal))
{
result = calculateActivityZoneGoal(activity, (IntervalsGoal)goal, act,
act.getGoalTrack(goal.Domain),
act.getGoalZoneTrack(goal.Image));
}
}
else
{
result = calculateActivityPointGoal(activity, (PointGoal)goal, act,
act.getGoalTrack(goal.Domain),
act.getGoalTrack(goal.Image));
}
if (result != null)
{
//results array are referenced by goal index. (Could be dictionary)
int resultIndex = goals.IndexOf(goal);
if (results[resultIndex] == null)
{
results[resultIndex] = new SortedList<Result, Result>();
}
if (results[resultIndex].Count > 0 &&
results[resultIndex].Count >= goal.Order)
{
Result last = Result.LastResult(results[resultIndex]);
if (result.BetterResult(last))
{
results[resultIndex].Remove(last);
}
}
if (results[resultIndex].Count < goal.Order)
{
results[resultIndex].Add(result, result);
}
}
}
}
public ActInfo(IActivity activity, IValueRangeSeries<DateTime> pauses, IList<Goal> goals)
{
this.Pauses = pauses;
ActivityInfo info = ActivityInfoCache.Instance.GetInfo(activity);
int increment = 5;
//restart:
{
//TBD: The following is what consumes almost all CPU, what is slowing down
IList<LapDetailInfo> laps = info.DistanceLapDetailInfo(20 + increment);
int length = laps.Count + 1;
aDateTime = new DateTime[length];
aTime = new double[length];
aDistance = new double[length];
aElevation = new double[length];
foreach (Goal goal in goals)
{
if (goal.Image == GoalParameter.PulseZone ||
goal.Image == GoalParameter.PulseZoneSpeedZone)
{
if (info.SmoothedHeartRateTrack.Max > 0)
{
aPulse = new double[length];
}
break;
}
}
foreach (Goal goal in goals)
{
if (goal.Image == GoalParameter.SpeedZone ||
goal.Image == GoalParameter.PulseZoneSpeedZone)
{
aSpeed = new double[length];
break;
}
}
DateTime dateTime = activity.StartTime;
aDateTime[0] = dateTime;
int index = 0;
double timeOffset = 0;
float distOffset = 0;
foreach (LapDetailInfo lap in laps)
{
dateTime = lap.EndTime;
if (ZoneFiveSoftware.Common.Data.Algorithm.DateTimeRangeSeries.IsPaused(lap.StartTime, pauses) ||
ZoneFiveSoftware.Common.Data.Algorithm.DateTimeRangeSeries.IsPaused(lap.EndTime, pauses))
{
//Adjust the extracted track info to pauses
timeOffset += lap.LapElapsed.TotalSeconds;
distOffset += lap.LapDistanceMeters;
//Skip this lap (only start checked)
continue;
}
if (index == 0)
{
//First point not yet valid, set 0 index
updateTracks(info, index, lap.StartTime, lap.StartElapsed.TotalSeconds - timeOffset, lap.StartDistanceMeters - distOffset);
}
index++;
//Time and distance must be calculated in the same way, why the following will not work
//double elapsed = ZoneFiveSoftware.Common.Data.Algorithm.DateTimeRangeSeries.TimeNotPaused(aDateTime[0], dateTime, pauses).TotalSeconds;
updateTracks(info, index, dateTime, lap.EndElapsed.TotalSeconds - timeOffset, lap.EndDistanceMeters - distOffset);
//This section is no longer needed (was when elapsed was lap.EndElapsed.TotalSeconds?)
//if (aTime[index] < aTime[index - 1])
//{
// aTime[index] = aTime[index - 1];
// increment += 5;
// goto restart;
//}
}
this.Length = index+1;
}
}
//Note: IItemTrackSelectionInfo uses Activity distances, avoid...
public TrailResultMarked(TrailResult tr, IValueRangeSeries<double> t)
{
trailResult = tr;
selInfo.MarkedDistances = t;
}
public TrailResultMarked(TrailResult tr, IValueRangeSeries<DateTime> t)
{
trailResult = tr;
selInfo.MarkedTimes = t;
selInfo.Activity = tr.Activity;
}
public static IList<IList<IGPSPoint>> GpsPoints(IGPSRoute gpsRoute, IValueRangeSeries<DateTime> selections)
{
IList<IList<IGPSPoint>> result = new List<IList<IGPSPoint>>();
if (selections != null && selections.Count > 0 && gpsRoute != null && gpsRoute.Count > 1)
{
//selection and gps points are sorted without overlap so traverse over gps points only once
//(previous version had much more complicated version, that also accounted for pauses)
int i = 0;
foreach (IValueRange<DateTime> sel in selections)
{
IList<IGPSPoint> track = new List<IGPSPoint>();
//Use start/end "with priority", even if extra points are added. Care needed if returning GPSRoute
DateTime t = DateTimeRangeSeries.Latest(sel.Lower, gpsRoute.StartTime);
ITimeValueEntry<IGPSPoint> pt = gpsRoute.GetInterpolatedValue(t);
if (pt != null)
{
track.Add(pt.Value);
}
while (i < gpsRoute.Count)
{
ITimeValueEntry<IGPSPoint> entry = gpsRoute[i];
DateTime time = gpsRoute.EntryDateTime(entry);
i++;
if (sel.Lower > time)
{
continue;
}
if (sel.Upper < time)
{
//Do not increase counter here, it could be needed
i--;
break;
}
track.Add(entry.Value);
}
t = DateTimeRangeSeries.Earliest(sel.Upper, gpsRoute.StartTime.AddSeconds(gpsRoute.TotalElapsedSeconds));
pt = gpsRoute.GetInterpolatedValue(t);
if (pt != null)
{
track.Add(pt.Value);
}
result.Add(track);
}
}
return result;
}
//ST IsPaused reports no pause if time matches, this also checks borders
private static bool IsPause(DateTime time, IValueRangeSeries<DateTime> pauses)
{
bool res = DateTimeRangeSeries.IsPaused(time, pauses);
if (!res)
{
foreach (IValueRange<DateTime> pause in pauses)
{
if (time.CompareTo(pause.Lower) >= 0 &&
time.CompareTo(pause.Upper) <= 0)
{
res = true;
break;
}
}
}
return res;
}
//Exclude the pauses from the selection
public static IValueRangeSeries<DateTime> excludePauses(IValueRangeSeries<DateTime> sels, IValueRangeSeries<DateTime> pauses)
{
IValueRangeSeries<DateTime> t = new ValueRangeSeries<DateTime>();
foreach (IValueRange<DateTime> tsel in sels)
{
foreach (IValueRange<DateTime> t1 in DateTimeRangeSeries.TimesNotPaused(
tsel.Lower, tsel.Upper, pauses))
{
t.Add(t1);
}
}
return t;
}
