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