/// <summary>
/// Assign rank to records
/// </summary>
/// <param name="records"></param>
/// <returns></returns>
private static List <Record> RankRecords(List <Record> records)
{
// Rank records
Record.RecordComparer comparer = new Record.RecordComparer();
comparer.ComparisonMethod = Record.RecordComparer.ComparisonType.AvgPace;
comparer.SortOrder = Record.RecordComparer.Order.Ascending;
if (records != null)
{
records.Sort(comparer);
int rank = 1;
int index = 0;
RecordCategory rankCategory = new RecordCategory();
if (records.Count > index)
{
rankCategory = records[index].Category;
rank = 1;
// Loop through all records assigning rank
while (index < records.Count)
{
records[index].Rank = rank;
index++;
rank++;
}
}
}
return(records);
}
/// <summary>
/// Returns the category record for a single activity
/// </summary>
/// <param name="activity">Activity to search for a record in</param>
/// <param name="category">Type/category of record to search for</param>
/// <returns></returns>
private static Record GetRecord(IActivity activity, RecordCategory category)
{
switch (category.Type)
{
case RecordCategory.RecordType.Distance:
return(GetDistancePaceRecord(activity, category));
case RecordCategory.RecordType.AllActivities:
return(GetAllActivities(activity, category));
default:
// Category should always be defined
return(null);
}
}
/// <summary>
/// Creates a set of records for a single specified category
/// </summary>
/// <param name="category">Category in which to find records for</param>
/// <param name="activities">List of activities to search</param>
public RecordSet(RecordCategory category, IEnumerable <IActivity> activities)
{
// Clear private record list
records = new List <Record>();
Record record;
this.category = category;
if (category.Type == RecordCategory.RecordType.Distance)
{
foreach (IActivity activity in activities)
{
if (CheckCategory(activity, category))
{
// NOTE: Here's a good debug point to investivate specific oddball activities
//if (activity.StartTime.Date == new DateTime(2010, 07, 25))
//{ }
record = GetRecord(activity, category);
if (record != null)
{
records.Add(record);
}
}
}
// Assign rank to each record in this record set
records = RankRecords(records);
}
else if (category.Type == RecordCategory.RecordType.AllActivities)
{
foreach (IActivity activity in activities)
{
record = GetRecord(activity, category);
records.Add(record);
}
}
else
{
// Store Extreme Overall Records
records = GetExtremeOverallRecordSet(activities, category);
}
//WriteRecordsToCSV(records);
}
/// <summary>
/// Checks to see if the activity's category is in the list
/// </summary>
/// <param name="act">Activity to check</param>
/// <param name="cat">RecordCategory to check against</param>
/// <returns></returns>
public static bool CheckCategory(IActivity act, RecordCategory cat)
{
if (cat.Display_Categories != null && cat.Display_Categories.Count > 0)
{
foreach (string refID in cat.Categories)
{
if (refID == act.Category.ReferenceId)
{
return(true);
}
}
return(false);
}
return(true);
}
public int CompareTo(object obj)
{
RecordCategory rc = (RecordCategory)obj;
if (rc.Centimeters > this.Centimeters)
{
return(-1);
}
else if (rc.Centimeters == this.Centimeters)
{
return(0);
}
else
{
return(1);
}
}
/// <summary>
/// Gets all Extreme Overall type records for a particular activity
/// </summary>
/// <param name="activities">Activity list to search in</param>
/// <param name="category"></param>
/// <returns></returns>
private static List <Record> GetExtremeOverallRecordSet(IEnumerable <IActivity> activities, RecordCategory category)
{
List <Record> extremeRecords = new List <Record>();
Record record;
int i = 0;
// Build a secondary all activity list to poll for all day records (multiple events on one day)
// Using an ArrayList for ease of removing records
ArrayList allAct = new ArrayList();
foreach (IActivity activity in activities)
{
if (CheckCategory(activity, category))
{
allAct.Add(activity);
}
}
foreach (IActivity activity in activities)
{
if (CheckCategory(activity, category))
{
switch (category.Type)
{
#region MaxTemperature
case RecordCategory.RecordType.MaxTemperature:
{
if (!float.IsNaN(activity.Weather.TemperatureCelsius) && activity.GPSRoute != null && activity.GPSRoute.Count > 0)
{
record = new Record(activity, category);
record.RecValue = Temperature.Convert(activity.Weather.TemperatureCelsius, Temperature.Units.Celsius, PluginMain.GetApplication().SystemPreferences.TemperatureUnits).ToString("N1") + Units.Temp;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].Activity.Weather.TemperatureCelsius > activity.Weather.TemperatureCelsius)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MinTemperature
case RecordCategory.RecordType.MinTemperature:
{
if (!float.IsNaN(activity.Weather.TemperatureCelsius) && activity.GPSRoute != null && activity.GPSRoute.Count > 0)
{
record = new Record(activity, category);
record.RecValue = Temperature.Convert(activity.Weather.TemperatureCelsius, Temperature.Units.Celsius, PluginMain.GetApplication().SystemPreferences.TemperatureUnits).ToString("N1") + Units.Temp;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].Activity.Weather.TemperatureCelsius < activity.Weather.TemperatureCelsius)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MaxDistance
case RecordCategory.RecordType.MaxDistance:
{
if (!float.IsNaN(activity.TotalDistanceMetersEntered) && activity.TotalDistanceMetersEntered != 0)
{
record = new Record(activity, category);
record.RecValue = record.ActualDistance + Units.Distance;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].ActualDistance > record.ActualDistance)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MaxTime
case RecordCategory.RecordType.TotalTime:
{
record = new Record(activity, category);
record.RecValue = record.TotalTime.ToString();
while (i < extremeRecords.Count)
{
if (extremeRecords[i].TotalTime > record.TotalTime)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
break;
}
#endregion
#region MaxSpeed
case RecordCategory.RecordType.MaxSpeed:
{
record = new Record(activity, category);
if (!float.IsNaN(record.MaxSpeed) && !float.IsInfinity(record.MaxSpeed))
{
record.RecValue = record.MaxSpeed.ToString("N2") + Units.Speed;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].MaxSpeed > record.MaxSpeed)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MaxHR
case RecordCategory.RecordType.MaxHR:
{
if (activity.HeartRatePerMinuteTrack != null)
{
record = new Record(activity, category);
record.RecValue = record.MaxHR.ToString("N0") + " bpm";
while (i < extremeRecords.Count)
{
if (extremeRecords[i].MaxHR > record.MaxHR)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region FastestSpeed
case RecordCategory.RecordType.FastestSpeed:
{
record = new Record(activity, category);
if (record.Speed != 0)
{
record.RecValue = record.Speed.ToString("N2") + Units.Speed;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].Speed > record.Speed)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region FastestPace
case RecordCategory.RecordType.FastestPace:
{
record = new Record(activity, category);
if (record.AvgPace != TimeSpan.Parse("00:00:00"))
{
record.RecValue = record.AvgPace.ToString() + Units.Pace;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].AvgPace < record.AvgPace)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region AvgHR
case RecordCategory.RecordType.AvgHR:
{
if (activity.HeartRatePerMinuteTrack != null)
{
record = new Record(activity, category);
record.RecValue = record.AvgHR.ToString("N0") + " bpm";
while (i < extremeRecords.Count)
{
if (extremeRecords[i].AvgHR > record.AvgHR)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MaxElevation
case RecordCategory.RecordType.MaxElevation:
{
if (activity.GPSRoute != null && activity.GPSRoute.Count > 0)
{
record = new Record(activity, category);
record.RecValue = record.MaxElevation.ToString("N0") + Units.Elevation;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].MaxElevation > record.MaxElevation)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MinElevation
case RecordCategory.RecordType.MinElevation:
{
if (activity.GPSRoute != null && activity.GPSRoute.Count > 0)
{
record = new Record(activity, category);
record.RecValue = record.MinElevation.ToString("N0") + Units.Elevation;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].MinElevation < record.MinElevation)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MaxCadence
case RecordCategory.RecordType.MaxCadence:
{
if (activity.CadencePerMinuteTrack != null)
{
record = new Record(activity, category);
record.RecValue = record.MaxCadence.ToString("N0") + " rpm";
while (i < extremeRecords.Count)
{
if (extremeRecords[i].MaxCadence > record.MaxCadence)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region ElevationDifference
case RecordCategory.RecordType.ElevationDifference:
{
if (activity.GPSRoute != null && activity.GPSRoute.Count > 0)
{
record = new Record(activity, category);
double minE, maxE;
maxE = record.MaxElevation;
minE = record.MinElevation;
record.RecValue = (maxE - minE).ToString("N0") + Units.Elevation;
while (i < extremeRecords.Count)
{
if ((extremeRecords[i].MaxElevation - extremeRecords[i].MinElevation) > (record.MaxElevation - record.MinElevation))
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MaxPower
case RecordCategory.RecordType.MaxPower:
{
if (activity.PowerWattsTrack != null)
{
record = new Record(activity, category);
record.RecValue = record.MaxPower.ToString("N0") + Units.Power;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].MaxPower > record.MaxPower)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region AvgPower
case RecordCategory.RecordType.AvgPower:
{
if (activity.PowerWattsTrack != null || activity.AveragePowerWattsEntered != 0)
{
record = new Record(activity, category);
record.RecValue = record.AvgPower.ToString("N0") + Units.Power;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].AvgPower > record.AvgPower)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MaxAscent
case RecordCategory.RecordType.MaxAscent:
{
if (activity.GPSRoute != null && activity.GPSRoute.Count > 0)
{
record = new Record(activity, category);
record.RecValue = record.TotalAscend.ToString("N0") + Units.Elevation;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].TotalAscend > record.TotalAscend)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MaxDescent
case RecordCategory.RecordType.MaxDescent:
{
if (activity.GPSRoute != null && activity.GPSRoute.Count > 0)
{
record = new Record(activity, category);
record.RecValue = record.TotalDescend.ToString("N0") + Units.Elevation;
while (i < extremeRecords.Count)
{
if (extremeRecords[i].TotalDescend < record.TotalDescend)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region TotalCalories
case RecordCategory.RecordType.TotalCalories:
{
if (activity.TotalCalories != 0)
{
record = new Record(activity, category);
record.RecValue = record.TotalCalories.ToString("N0");
while (i < extremeRecords.Count)
{
if (extremeRecords[i].TotalCalories > record.TotalCalories)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region AvgCadence
case RecordCategory.RecordType.AvgCadence:
{
if (activity.CadencePerMinuteTrack != null)
{
record = new Record(activity, category);
record.RecValue = record.AvgCadence.ToString("N0") + " rpm";
while (i < extremeRecords.Count)
{
if (extremeRecords[i].AvgCadence > record.AvgCadence)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region TotalTimeOneDay
case RecordCategory.RecordType.TotalTimeOneDay:
{
TimeSpan totTime = new TimeSpan();
record = new Record(activity, category);
for (int c = 0; c < allAct.Count; c++)
{
IActivity act2 = (IActivity)allAct[c];
Record rec2 = new Record(act2, category);
if (act2.StartTime.ToLocalTime().Date == record.StartDateTime.ToLocalTime().Date)
{
totTime += rec2.TotalTime;
allAct.Remove(act2);
c--;
}
}
if (totTime != TimeSpan.Parse("00:00:00"))
{
while (i < extremeRecords.Count)
{
if (TimeSpan.Parse(extremeRecords[i].RecValue) > totTime)
{
i++;
}
else
{
break;
}
}
record.RecValue = totTime.ToString();
DateTime newDt = new DateTime(record.StartDateTime.Year, record.StartDateTime.Month, record.StartDateTime.Day);
record.StartDateTime = newDt;
// TODO: Determine how a record is getting a minDate as it's startdate
if (newDt.Year == 1)
{
}
extremeRecords.Insert(i, record);
}
i = 0;
break;
}
#endregion
#region TotalDistanceOneDay
case RecordCategory.RecordType.TotalDistanceOneDay:
{
double totDist = 0;
record = new Record(activity, category);
for (int c = 0; c < allAct.Count; c++)
{
IActivity act2 = (IActivity)allAct[c];
Record rec2 = new Record(act2, category);
if (act2.StartTime.ToLocalTime().Date == record.StartDateTime.ToLocalTime().Date)
{
totDist += rec2.ActualDistance;
allAct.Remove(act2);
c--;
}
}
if (totDist != 0)
{
while (i < extremeRecords.Count)
{
if (Convert.ToDouble(extremeRecords[i].RecValue) > totDist)
{
i++;
}
else
{
break;
}
}
record.RecValue = totDist.ToString("N2");
DateTime newDt = new DateTime(record.StartDateTime.Year, record.StartDateTime.Month, record.StartDateTime.Day);
record.StartDateTime = newDt;
// TODO: Determine how a record is getting a minDate as it's startdate
if (newDt.Year == 1)
{
}
extremeRecords.Insert(i, record);
}
i = 0;
break;
}
#endregion
#region MaxGrade
case RecordCategory.RecordType.MaxGrade:
{
if (activity.GPSRoute != null && activity.GPSRoute.Count > 0)
{
record = new Record(activity, category);
record.RecValue = record.MaxGrade.ToString("N1") + " %";
while (i < extremeRecords.Count)
{
if (extremeRecords[i].MaxGrade > record.MaxGrade)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
#region MinGrade
case RecordCategory.RecordType.MinGrade:
{
if (activity.GPSRoute != null && activity.GPSRoute.Count > 0)
{
record = new Record(activity, category);
record.RecValue = record.MinGrade.ToString("N1") + " %";
while (i < extremeRecords.Count)
{
if (extremeRecords[i].MinGrade < record.MinGrade)
{
i++;
}
else
{
break;
}
}
extremeRecords.Insert(i, record);
i = 0;
}
break;
}
#endregion
}
}
}
for (i = 0; i < extremeRecords.Count; i++)
{
extremeRecords[i].Rank = i + 1;
}
return(extremeRecords);
}
private static Record GetAllActivities(IActivity activity, RecordCategory category)
{
Record record = new Record(activity, category);
return(record);
}
private static Record GetDistancePaceRecord(IActivity activity, RecordCategory category)
{
float fastestSpeed = 0;
float currentSpeed;
float currentDistance = 0;
if (activity.GPSRoute != null && activity.GPSRoute.TotalElapsedSeconds > 0 && ActivityInfoCache.Instance.GetInfo(activity).DistanceMetersMoving >= category.Meters)
{
int recordStart = 0, recordEnd = 0, startIndex, endIndex = 0;
List <double> p2pDistance = new List <double>();
// Go through each starting point
for (startIndex = 0; startIndex < activity.GPSRoute.Count; startIndex++)
{
// Find end GPS point that's the proper distance away
while (currentDistance <= category.Meters)
{
endIndex += 1;
// Typical return point. End has exceeded route. Construct and return record for this activity/category.
if (endIndex >= activity.GPSRoute.Count)
{
// Construct record GPS route
GPSRoute recordGPS = new GPSRoute();
NumericTimeDataSeries recordHRTrack = new NumericTimeDataSeries();
NumericTimeDataSeries pwrTrack = new NumericTimeDataSeries();
NumericTimeDataSeries elevTrack = new NumericTimeDataSeries();
NumericTimeDataSeries cadTrack = new NumericTimeDataSeries();
DistanceDataTrack distTrack = new DistanceDataTrack();
for (int i = recordStart; i <= recordEnd; i++)
{
// Record information/statistics
DateTime time = activity.GPSRoute.EntryDateTime(activity.GPSRoute[i]);
recordGPS.Add(time, activity.GPSRoute[i].Value);
if (activity.HeartRatePerMinuteTrack != null &&
activity.HeartRatePerMinuteTrack.StartTime <= time &&
activity.HeartRatePerMinuteTrack.StartTime.AddSeconds(activity.HeartRatePerMinuteTrack.TotalElapsedSeconds) >= time)
{
recordHRTrack.Add(time, activity.HeartRatePerMinuteTrack.GetInterpolatedValue(time).Value);
}
if (activity.PowerWattsTrack != null &&
activity.PowerWattsTrack.StartTime <= time &&
activity.PowerWattsTrack.StartTime.AddSeconds(activity.PowerWattsTrack.TotalElapsedSeconds) >= time)
{
pwrTrack.Add(time, activity.PowerWattsTrack.GetInterpolatedValue(time).Value);
}
if (activity.CadencePerMinuteTrack != null &&
activity.CadencePerMinuteTrack.StartTime <= time &&
activity.CadencePerMinuteTrack.StartTime.AddSeconds(activity.CadencePerMinuteTrack.TotalElapsedSeconds) >= time)
{
cadTrack.Add(time, activity.CadencePerMinuteTrack.GetInterpolatedValue(time).Value);
}
if (activity.DistanceMetersTrack != null &&
activity.DistanceMetersTrack.StartTime <= time &&
activity.DistanceMetersTrack.StartTime.AddSeconds(activity.DistanceMetersTrack.TotalElapsedSeconds) >= time)
{
distTrack.Add(time, activity.DistanceMetersTrack.GetInterpolatedValue(time).Value);
}
if (activity.ElevationMetersTrack != null &&
activity.ElevationMetersTrack.StartTime <= time &&
activity.ElevationMetersTrack.StartTime.AddSeconds(activity.ElevationMetersTrack.TotalElapsedSeconds) >= time)
{
elevTrack.Add(time, activity.ElevationMetersTrack.GetInterpolatedValue(time).Value);
}
}
// Return record
Record record = new Record(activity, category, recordGPS, recordHRTrack, pwrTrack, cadTrack, distTrack, elevTrack);
return(record);
}
else
{
// Add to end of route until category distance is found
currentDistance += activity.GPSRoute[endIndex].Value.DistanceMetersToPoint(activity.GPSRoute[endIndex - 1].Value);
}
}
// In meters / second
currentSpeed = currentDistance / (activity.GPSRoute[endIndex].ElapsedSeconds - activity.GPSRoute[startIndex].ElapsedSeconds);
// Store fastest info (in meters / second)
if (fastestSpeed < currentSpeed)
{
fastestSpeed = currentSpeed;
recordStart = startIndex;
recordEnd = endIndex;
}
// Remove first point from routeDistance, and go to next starting point.
currentDistance -= activity.GPSRoute[startIndex].Value.DistanceMetersToPoint(activity.GPSRoute[startIndex + 1].Value);
}
}
// Activity does not contain GPS data or not long enough
return(null);
}
//public IDistanceDataTrack GetSmoothedDistanceTrack(int seconds, out float min, out float max)
//{
// IDistanceDataTrack distanceTrack;
// if (record.Activity.DistanceMetersTrack != null)
// {
// // #1 Use Distance track from activity
// distanceTrack = record.Activity.DistanceMetersTrack;
// }
// else
// {
// if (record.Activity.GPSRoute != null)
// {
// // #2 Otherwise create a distance track from GPS
// distanceTrack = Utilities.CreateDistanceDataTrack(record.Activity);
// return Utilities.STSmooth(distanceTrack, seconds, min, max);
// }
// else
// {
// // Else, no distance track, and cannot create one.
// distanceTrack = new DistanceDataTrack();
// }
// }
//}
//public INumericTimeDataSeries GetSmoothedGradeTrack(int seconds, out float min, out float max)
//{
// NumericTimeDataSeries gradeTrack = new NumericTimeDataSeries();
// for (int i = 0; i < record.Activity.ElevationMetersTrack.Count; i++)
// {
// if (i == 0)
// {
// gradeTrack.Add(record.Activity.ElevationMetersTrack[i].ElapsedSeconds, 0);
// }
// }
//}
#region Constructors
public Feature(IActivity activity, feature_type type, DateTime inStartTime, DateTime inEndTime)
{
startTime = inStartTime;
endTime = inEndTime;
added = false;
hillNumber = 0;
_feature_type = type;
masterActivityID = activity.ReferenceId;
// Default fill and line color
fillColor = Color.FromArgb(125, 146, 94, 9);
lineColor = Color.FromArgb(255, 146, 94, 9);
lineWidth = 1;
selectedColor = Color.Empty;
routeWidth = PluginMain.GetApplication().SystemPreferences.RouteSettings.RouteWidth;
IGPSRoute recordGPS = new GPSRoute();
INumericTimeDataSeries recordHRTrack = new NumericTimeDataSeries();
INumericTimeDataSeries pwrTrack = new NumericTimeDataSeries();
INumericTimeDataSeries elevTrack = new NumericTimeDataSeries();
INumericTimeDataSeries cadTrack = new NumericTimeDataSeries();
IDistanceDataTrack distTrack = new DistanceDataTrack();
RecordCategory category = new RecordCategory();
ActivityInfo ai = ActivityInfoCache.Instance.GetInfo(activity);
DateTime start = activity.StartTime;
if (activity.GPSRoute != null)
{
// Check and make sure the route has points
if (activity.GPSRoute.Count > 0)
{
// If the time passed in is before the start of the gps track, get the first value
if (activity.GPSRoute.StartTime > inStartTime)
{
startPoint = activity.GPSRoute[0].Value;
}
else
{
// Set the start point
ITimeValueEntry <IGPSPoint> sPoint = activity.GPSRoute.GetInterpolatedValue(inStartTime);
if (sPoint != null)
{
startPoint = sPoint.Value;
}
}
// If the time passed in is after the end of the gps track, get the last value
if (activity.GPSRoute.StartTime.AddSeconds(activity.GPSRoute[activity.GPSRoute.Count - 1].ElapsedSeconds) < inEndTime)
{
endPoint = activity.GPSRoute[activity.GPSRoute.Count - 1].Value;
}
else
{
// Set the end point
ITimeValueEntry <IGPSPoint> ePoint = activity.GPSRoute.GetInterpolatedValue(inEndTime);
if (ePoint != null)
{
endPoint = ePoint.Value;
}
}
}
// Create the GPSRoute
for (int i = 0; i < activity.GPSRoute.Count; i++)
{
if (activity.GPSRoute.StartTime.AddSeconds(activity.GPSRoute[i].ElapsedSeconds) >= inStartTime &&
activity.GPSRoute.StartTime.AddSeconds(activity.GPSRoute[i].ElapsedSeconds) <= inEndTime)
{
recordGPS.Add(activity.GPSRoute.StartTime.AddSeconds(activity.GPSRoute[i].ElapsedSeconds), activity.GPSRoute[i].Value);
}
}
}
// Create the Distance Track
INumericTimeDataSeries allDistanceTrack = ai.MovingDistanceMetersTrack; // Utilities.GetDistanceTrack(activity);
INumericTimeDataSeries allElevationTrack = ai.SmoothedElevationTrack; // Utilities.GetElevationTrack(activity);
// Work your way through the moving meters track to create all others
if (allDistanceTrack != null)
{
for (int i = 0; i < allDistanceTrack.Count; i++)
{
DateTime time = allDistanceTrack.StartTime.AddSeconds(allDistanceTrack[i].ElapsedSeconds);
if (time >= inStartTime &&
time <= inEndTime)
{
// Add the distance point
distTrack.Add(time, allDistanceTrack[i].Value);
ITimeValueEntry <float> point = null;
// Find the elevation point at this time and add it
if (allElevationTrack != null && allElevationTrack.Count > 0)
{
point = allElevationTrack.GetInterpolatedValue(time);
if (point != null)
{
elevTrack.Add(time, point.Value);
}
}
// Find the HR point at this time and add it
if (activity.HeartRatePerMinuteTrack != null && activity.HeartRatePerMinuteTrack.Count > 0)
{
point = activity.HeartRatePerMinuteTrack.GetInterpolatedValue(time);
if (point != null)
{
recordHRTrack.Add(time, point.Value);
}
}
// Find the power point at this time and add it
if (activity.PowerWattsTrack != null && activity.PowerWattsTrack.Count > 0)
{
point = activity.PowerWattsTrack.GetInterpolatedValue(time);
if (point != null)
{
pwrTrack.Add(time, point.Value);
}
}
// Find the cadence point at this time and add it
if (activity.CadencePerMinuteTrack != null && activity.CadencePerMinuteTrack.Count > 0)
{
point = activity.CadencePerMinuteTrack.GetInterpolatedValue(time);
if (point != null)
{
cadTrack.Add(time, point.Value);
}
}
}
else if (allDistanceTrack.StartTime.AddSeconds(allDistanceTrack[i].ElapsedSeconds) > inEndTime)
{
break;
}
}
}
// Get the start/end distance
if (distTrack != null && distTrack.Count > 0)
{
startDistance = distTrack[0].Value;
endDistance = distTrack[distTrack.Count - 1].Value;
}
else
{
startDistance = 0;
endDistance = 0;
}
// Get the start/end elevation
if (elevTrack != null && elevTrack.Count > 0)
{
startElevation = elevTrack[0].Value;
endElevation = elevTrack[elevTrack.Count - 1].Value;
}
else
{
startElevation = 0;
endElevation = 0;
}
// Build the record
record = new Record(activity, category, recordGPS, recordHRTrack, pwrTrack, cadTrack, distTrack, elevTrack, inStartTime);
// Create a reference id for this hill
refId = Guid.NewGuid().ToString("D");
double distanceX = endDistance - startDistance;
distance = distanceX;
double elev = endElevation - startElevation;
elevGain = elev;
// Find the start percents from the distance track
if (allDistanceTrack != null && allDistanceTrack.Count > 0)
{
startPercentDistance = startDistance / allDistanceTrack[allDistanceTrack.Count - 1].Value;
endPercentDistance = endDistance / allDistanceTrack[allDistanceTrack.Count - 1].Value;
startPercentTime = ((inStartTime - allDistanceTrack.StartTime).TotalSeconds / allDistanceTrack[allDistanceTrack.Count - 1].ElapsedSeconds);
endPercentTime = ((inEndTime - allDistanceTrack.StartTime).TotalSeconds / allDistanceTrack[allDistanceTrack.Count - 1].ElapsedSeconds);
}
// Calculate the VAM (Velocity Ascended, Meters per hour)
// Calculate the W/kg (Relative power)
vam = 0;
wKg = 0;
if (elevGain > 0)
{
vam = (elevGain * 60f * 60f) / record.TotalTime.TotalSeconds;
wKg = vam / ((2 + (avgGrade * 10f)) * 100f);
}
ActivityInfo aiRec = ActivityInfoCache.Instance.GetInfo(record.Activity);
stoppedTime = aiRec.TimeNotMoving;
}
/// <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;
}
