private Task <ActivityHeaderViewModel> CreateHeaderViewModelAsync(Activity activity)
{
return(Task.Run(
() =>
{
var lap = activity.Lap[0];
double maxSpeed = lap.MaximumSpeed * 3.6;
EffortComputer effortComputer = lap.AverageHeartRateBpm != null
? HumanEffortComputer.ByHeartBeat
: HumanEffortComputer.BySpeed.OverrideDefaultMaxValue(maxSpeed);
var dispersion = new SortedDictionary <double, IDispersionSpan>();
Trackpoint previousPoint = lap.Track[0];
DateTime startTime = lap.Track[0].Time;
for (int index = 0; index < lap.Track.Count; index++)
{
Trackpoint currentPoint = lap.Track[index];
TimeSpan elapsedTime = currentPoint.Time - startTime;
double?speed = null;
if (previousPoint != null && previousPoint.Position != null &&
previousPoint.DistanceMeters > 0 && currentPoint.Position != null &&
currentPoint.DistanceMeters > 0 && elapsedTime.TotalSeconds > 0)
{
double kilometersTraveled = GeoCalculation.HaversineDistance(
new LatLong(
previousPoint.Position.LatitudeDegrees,
previousPoint.Position.LongitudeDegrees),
new LatLong(
currentPoint.Position.LatitudeDegrees,
currentPoint.Position.LongitudeDegrees));
double hoursElapsed = (elapsedTime - (previousPoint.Time - startTime)).TotalHours;
speed = kilometersTraveled / hoursElapsed;
}
double?value = lap.AverageHeartRateBpm != null ? currentPoint.HeartRateBpm?.Value : speed;
if (value == null)
{
previousPoint = currentPoint;
continue;
}
var elapsedTimeSinceLastPoint = currentPoint.Time - previousPoint.Time;
EffortSpan effortSpan = effortComputer.GetSpan(value);
if (!dispersion.ContainsKey(effortSpan.Threshold))
{
dispersion.Add(effortSpan.Threshold, new DispersionSpan(effortSpan.Color, 0));
}
dispersion[effortSpan.Threshold]
.IncrementValue(elapsedTimeSinceLastPoint.TotalMilliseconds);
previousPoint = currentPoint;
}
return new ActivityHeaderViewModel(activity.ToActivityHeader(), dispersion.Values.ToList());
}));
}
protected Task <ActivityHeaderModel> CreateHeaderViewModelAsync(RideModel ride)
{
return(Task.Run(
() =>
{
var lap = ride.Laps[0];
double maxSpeed = lap.MaximumSpeed * 3.6;
EffortComputer effortComputer = HumanEffortComputer.BySpeed.OverrideDefaultMaxValue(maxSpeed);
var dispersion = new SortedDictionary <double, IDispersionSpan>();
var previousPoint = lap.Trackpoints[0];
DateTime startTime = lap.Trackpoints[0].CreatedDate.Value;
for (int index = 0; index < lap.Trackpoints.Count; index++)
{
var currentPoint = lap.Trackpoints[index];
TimeSpan elapsedTime = currentPoint.CreatedDate.Value - startTime;
double?speed = null;
if (previousPoint != null && previousPoint.Latitude != null && previousPoint.Longitude != null &&
/*previousPoint.DistanceMeters > 0 && currentPoint.Position != null
* && currentPoint.DistanceMeters > 0 &&*/elapsedTime.TotalSeconds > 0)
{
double kilometersTraveled = GeoCalculation.HaversineDistance(
new LatLong(
previousPoint.Latitude,
previousPoint.Longitude),
new LatLong(
currentPoint.Latitude,
currentPoint.Longitude));
double hoursElapsed = (elapsedTime - (previousPoint.CreatedDate.Value - startTime)).TotalHours;
speed = kilometersTraveled / hoursElapsed;
}
//double? value = lap.AverageHeartRateBpm != null ? currentPoint.HeartRateBpm?.Value : speed;
//if (value == null)
//{
// previousPoint = currentPoint;
// continue;
//}
//var elapsedTimeSinceLastPoint = currentPoint.CreatedDate - previousPoint.CreatedDate;
//EffortSpan effortSpan = effortComputer.GetSpan(value);
//if (!dispersion.ContainsKey(effortSpan.Threshold))
//{
// dispersion.Add(effortSpan.Threshold, new DispersionSpan(effortSpan.Color, 0));
//}
//dispersion[effortSpan.Threshold]
// .IncrementValue(elapsedTimeSinceLastPoint.TotalMilliseconds);
previousPoint = currentPoint;
}
return new ActivityHeaderModel(ride.ToActivityHeader(), dispersion.Values.ToList());
}));
}
/// <summary>
/// Creation with SessionDisplayablePoints.
/// </summary>
/// <param name="sessionPoints">The session points.</param>
/// <param name="bottomLeft">The bottom left.</param>
/// <param name="topRight">The top right.</param>
/// <param name="totalDurationInSeconds">The total duration in seconds.</param>
public SessionMap(
List <SessionDisplayablePoint> sessionPoints,
Position bottomLeft,
Position topRight)
{
SessionPoints = sessionPoints;
BottomLeft = bottomLeft;
TopRight = topRight;
Region = GeoCalculation.BoundsToMapSpan(bottomLeft, topRight);
}
public SessionMapInfo(
IReadOnlyList <SessionDisplayablePoint> sessionPoints,
Position bottomLeft,
Position topRight,
int totalDurationInSeconds)
{
SessionPoints = sessionPoints;
BottomLeft = bottomLeft;
TopRight = topRight;
Region = GeoCalculation.BoundsToMapSpan(bottomLeft, topRight);
TotalDurationInSeconds = totalDurationInSeconds;
}
/// <summary>
/// Initializes a new instance of the <see cref="SessionMap" /> class.
/// </summary>
public SessionMap()
{
SessionPoints = new List <SessionDisplayablePoint>();
double topLatitude = LatLong.Min.Latitude;
double bottomLatitude = LatLong.Max.Latitude;
double leftLongitude = LatLong.Max.Longitude;
double rightLongitude = LatLong.Min.Longitude;
BottomLeft = new Position(bottomLatitude, leftLongitude);
TopRight = new Position(topLatitude, rightLongitude);
Region = GeoCalculation.BoundsToMapSpan(BottomLeft, TopRight);
}
/// <summary>
/// Adds the specified session displayable point.
/// </summary>
/// <param name="sessionDisplayablePoint">The session displayable point.</param>
public void Add(ActivityPoint point)
{
SessionDisplayablePoint previousPoint =
SessionPoints.Count > 0
? SessionPoints.Last()
: null;
DateTime startTime = point.TimeStamp;
SessionDisplayablePoint sessionDisplayablePoint;
TimeSpan elapsedTime = point.TimeStamp - startTime;
double?speed = point.Speed;
if (speed == null &&
previousPoint != null &&
previousPoint.HasPosition &&
previousPoint.Distance.HasValue &&
point.Position != LatLong.Empty &&
point.DistanceInMeters > 0 &&
elapsedTime.TotalSeconds > 0)
{
double kilometersTraveled =
GeoCalculation.HaversineDistance(previousPoint.Position, point.Position);
double hoursElapsed = (elapsedTime - previousPoint.Time).TotalHours;
speed = kilometersTraveled / hoursElapsed;
}
sessionDisplayablePoint = new SessionDisplayablePoint(
elapsedTime,
point.DistanceInMeters,
point.AltitudeInMeters,
speed,
point.Position);
if (GeoCalculation.IsPointNewLeftBottom(BottomLeft, sessionDisplayablePoint.Position.ToPosition()) ||
GeoCalculation.IsPointNewTopRight(TopRight, sessionDisplayablePoint.Position.ToPosition()))
{
BottomLeft = sessionDisplayablePoint.Position.ToPosition();
TopRight = sessionDisplayablePoint.Position.ToPosition();
Region = GeoCalculation.BoundsToMapSpan(BottomLeft, TopRight);
}
SessionPoints.Add(sessionDisplayablePoint);
RefreshColors();
}
public static SessionMapInfo Create(
IReadOnlyList <ActivityPoint> points,
Func <ISessionDisplayablePoint, Color?> colorBaseValueSelector,
int markerInterval = int.MaxValue,
int displayDistanceInterval = int.MaxValue)
{
if (points == null || points.Count < 2)
{
throw new ArgumentException();
}
var sessionPoints = new SessionDisplayablePoint[points.Count];
double topLatitude = LatLong.Min.Latitude;
double bottomLatitude = LatLong.Max.Latitude;
double leftLongitude = LatLong.Max.Longitude;
double rightLongitude = LatLong.Min.Longitude;
int nextMarkerDistance = markerInterval;
int nextDisplayDistance = displayDistanceInterval;
SessionDisplayablePoint previousPoint = null;
DateTime startTime = points[0].TimeStamp;
for (int index = 0; index < points.Count; index++)
{
ActivityPoint point = points[index];
if (point.Position != LatLong.Empty)
{
topLatitude = Math.Max(point.Position.Latitude, topLatitude);
bottomLatitude = Math.Min(point.Position.Latitude, bottomLatitude);
leftLongitude = Math.Min(point.Position.Longitude, leftLongitude);
rightLongitude = Math.Max(point.Position.Longitude, rightLongitude);
}
bool hasMarker = false;
if (point.DistanceInMeters > nextMarkerDistance)
{
hasMarker = true;
nextMarkerDistance += markerInterval;
}
string displayDistance = null;
if (point.DistanceInMeters > nextDisplayDistance)
{
displayDistance = nextDisplayDistance.ToString();
nextDisplayDistance += displayDistanceInterval;
}
TimeSpan elapsedTime = point.TimeStamp - startTime;
double speed = 0;
if (previousPoint != null &&
previousPoint.HasPosition &&
previousPoint.Distance.HasValue &&
point.Position != LatLong.Empty &&
point.DistanceInMeters > 0 &&
elapsedTime.TotalSeconds > 0)
{
double kilometersTraveled =
GeoCalculation.HaversineDistance(previousPoint.Position, point.Position);
double hoursElapsed = (elapsedTime - previousPoint.Time).TotalHours;
speed = kilometersTraveled / hoursElapsed;
}
var currentPoint = sessionPoints[index] = new SessionDisplayablePoint(
elapsedTime,
point.HeartRate,
point.DistanceInMeters,
point.AltitudeInMeters,
speed,
point.Position,
hasMarker,
displayDistance);
Color mapPointColor =
colorBaseValueSelector(currentPoint) ?? previousPoint?.MapPointColor ?? Color.Gray;
currentPoint.SetPointColor(mapPointColor);
previousPoint = currentPoint;
}
return(new SessionMapInfo(
sessionPoints,
new Bounds(
new Position(bottomLatitude, leftLongitude),
new Position(topLatitude, rightLongitude)),
previousPoint != null ? (int)previousPoint.Time.TotalSeconds : 0));
}
/// <summary>
/// Creation with ActivityPoints and custom ColorSelector.
/// </summary>
/// <param name="points">The points.</param>
/// <param name="colorBaseValueSelector">The color base value selector.</param>
/// <returns></returns>
public static SessionMap Create(
List <ActivityPoint> points,
Func <ISessionDisplayablePoint, Color?> colorBaseValueSelector)
{
if (points == null)
{
Debug.WriteLine("SessionMap points is null");
//throw new ArgumentException();
return(null);
}
// mindestens zwei punkte für Geschwindigkeitsberechnung
if (points.Count < 2)
{
Debug.WriteLine("SessionMap points not greater than 2");
//throw new ArgumentException();
return(null);
}
var sessionPoints = new SessionDisplayablePoint[points.Count];
double topLatitude = LatLong.Min.Latitude;
double bottomLatitude = LatLong.Max.Latitude;
double leftLongitude = LatLong.Max.Longitude;
double rightLongitude = LatLong.Min.Longitude;
SessionDisplayablePoint previousPoint = null;
DateTime startTime = points[0].TimeStamp;
for (int index = 0; index < points.Count; index++)
{
ActivityPoint point = points[index];
if (point.Position != LatLong.Empty)
{
topLatitude = Math.Max(point.Position.Latitude, topLatitude);
bottomLatitude = Math.Min(point.Position.Latitude, bottomLatitude);
leftLongitude = Math.Min(point.Position.Longitude, leftLongitude);
rightLongitude = Math.Max(point.Position.Longitude, rightLongitude);
}
TimeSpan elapsedTime = point.TimeStamp - startTime;
double?speed = point.Speed;
if (speed == null &&
previousPoint != null &&
previousPoint.HasPosition &&
previousPoint.Distance.HasValue &&
point.Position != LatLong.Empty &&
point.DistanceInMeters > 0 &&
elapsedTime.TotalSeconds > 0)
{
double kilometersTraveled =
GeoCalculation.HaversineDistance(previousPoint.Position, point.Position);
double hoursElapsed = (elapsedTime - previousPoint.Time).TotalHours;
speed = kilometersTraveled / hoursElapsed;
}
var currentPoint = sessionPoints[index] = new SessionDisplayablePoint(
elapsedTime,
point.DistanceInMeters,
point.AltitudeInMeters,
speed,
point.Position);
Color mapPointColor =
colorBaseValueSelector(currentPoint)
?? previousPoint?.MapPointColor
?? Color.Gray;
currentPoint.SetPointColor(mapPointColor);
previousPoint = currentPoint;
}
return(new SessionMap(
sessionPoints.ToList(),
new Position(bottomLatitude, leftLongitude),
new Position(topLatitude, rightLongitude)));
}
