public static IList <EditTrailRow> getEditTrailRows(Trail tgps, TrailResult tr) { IList <EditTrailRow> result = new List <EditTrailRow>(); int i = 0; int inc = 1; //The result index may not match the trailGPS index if (tgps.IsCompleteActivity) { //An extra point at start/end has been added compared to the trail points i = 1; } if (tr != null && tr.Reverse) { i = tr.TrailPointDateTime.Count - 1 - i; inc = -1; } foreach (TrailGPSLocation t in tgps.TrailLocations) { EditTrailRow row = new EditTrailRow(t, tr, i); result.Add(row); i += inc; } return(result); }
//Mark all public TrailResultMarked(TrailResult tr) { this.trailResult = tr; if (tr is SummaryTrailResult) { //Just fake a selection, dont care if time is enough... this.selInfo.Activity = Controller.TrailController.Instance.ReferenceActivity; this.selInfo.MarkedTimes = new ValueRangeSeries <DateTime>(); DateTime endTime; try { endTime = ZoneFiveSoftware.Common.Data.Algorithm.DateTimeRangeSeries.AddTimeAndPauses( this.selInfo.Activity.StartTime, tr.Duration, this.selInfo.Activity.TimerPauses); } catch { endTime = this.selInfo.Activity.StartTime + tr.Duration; } this.selInfo.MarkedTimes.Add(new ValueRange <DateTime>( this.selInfo.Activity.StartTime, endTime)); } else { this.selInfo.MarkedTimes = tr.GetSelInfo(true); this.selInfo.Activity = tr.Activity; } }
private static float[] GetTimeChartResultFromDateTime(bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, DateTime d1, DateTime d2) { //Convert to distance display unit, Time is always in seconds float x1 = GetTimeChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, d1); float x2 = GetTimeChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, d2); return(new float[] { x1, x2 }); }
private static float[] GetDistChartResultFromDistResult(bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, double t1, double t2) { //distance is for result, then to display units float x1 = GetDistChartResultFromDistResult(isOffset, tr, ReferenceTrailResult, t1); float x2 = GetDistChartResultFromDistResult(isOffset, tr, ReferenceTrailResult, t2); return(new float[] { x1, x2 }); }
public void UpdateRow(TrailResult tr, TrailGPSLocation t) { this.TrailGPS = t; if (tr != null && m_resultPointIndex < tr.TrailPointDateTime.Count) { SetDistance(tr, tr.TrailPointDateTime[m_resultPointIndex]); } }
//Reset calculations, without changing selected activities public void Reset() { TrailResult.Reset(); foreach (ActivityTrail at in m_CurrentOrderedTrails) { at.Init(); } //activityGps handled separately }
//Marked part of a track public static IList<TrailMapPolyline> GetTrailMapPolyline(TrailResult tr, TrailsItemTrackSelectionInfo sel) { IList<TrailMapPolyline> results = new List<TrailMapPolyline>(); foreach (IList<IGPSPoint> gp in tr.GpsPoints(sel)) { results.Add(new TrailMapPolyline(gp, UnitUtil.GetApplication().SystemPreferences.RouteSettings.RouteWidth * 2, MarkedColor(tr.TrailColor), tr, "m" + results.Count)); } return results; }
//Marked part of a track public static IList <TrailMapPolyline> GetTrailMapMarkedPolyline(TrailResult tr, TrailsItemTrackSelectionInfo sel) { IList <TrailMapPolyline> results = new List <TrailMapPolyline>(); foreach (IList <IGPSPoint> gp in tr.GpsPoints(sel)) { results.Add(new TrailMapPolyline(gp, RouteWidth() * 2, MarkedColor(tr.ResultColor.LineNormal), tr, "m" + cSeparator + results.Count)); } return(results); }
//Note: IItemTrackSelectionInfo uses Activity distances, avoid... //public TrailResultMarked(TrailResult tr, IValueRangeSeries<double> t) //{ // trailResult = tr; // selInfo.MarkedDistances = t; //} public TrailResultMarked(TrailResult tr, IItemTrackSelectionInfo t) { this.trailResult = tr; this.selInfo.SetFromSelection(t, tr.Activity); if (selInfo.MarkedTimes != null) { selInfo.MarkedTimes = TrailsItemTrackSelectionInfo.excludePauses(selInfo.MarkedTimes, tr.Pauses); } //Note that SelectedTime can still include paused time }
/*******************************************************/ private static float GetTimeChartResultFromDateTime(bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, DateTime d1) { float x1 = (float)(tr.GetTimeResult(d1)); if (isOffset) { float nextElapsed; x1 += GetChartResultsResyncOffset(true, tr, ReferenceTrailResult, x1, out nextElapsed); } x1 += tr.GetXOffset(true, ReferenceTrailResult); return(x1); }
/****************************************************/ private static float GetChartResultFromDateTime(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, DateTime t) { //Note: Selecting in Route gives unpaused distance, but this should be handled in the selection if (xIsTime) { return(GetTimeChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, t)); } else { return(GetDistChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, t)); } }
private static float GetDistChartResultFromDistResult(bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, double t1) { //distance is for result, then to display units float x1 = (float)t1; if (isOffset) { float nextElapsed; x1 += GetChartResultsResyncOffset(false, tr, ReferenceTrailResult, x1, out nextElapsed); } x1 += tr.GetXOffset(false, ReferenceTrailResult); x1 = (float)TrackUtil.DistanceConvertFrom(x1, ReferenceTrailResult); return(x1); }
public void UpdateRow(TrailResult tr, DateTime d1) { //ITimeValueEntry<IGPSPoint> entry = tr.Activity.GPSRoute.GetInterpolatedValue(d1); //if (entry != null) //{ // this.TrailGPS.GpsLocation = new GPSLocation( // entry.Value.LatitudeDegrees, // entry.Value.LongitudeDegrees); //} if (tr != null) { IGPSPoint t = Utils.TrackUtil.getGpsLoc(tr.Activity, d1); this.TrailGPS.GpsPoint = t; SetDistance(tr, d1); } }
//A trail consisting of several parts (due to pauses) public static IList <TrailMapPolyline> GetTrailMapPolyline(TrailResult tr) { IList <TrailMapPolyline> results = new List <TrailMapPolyline>(); string s = "r"; if (tr is ChildTrailResult) { s = "c" + tr.Order; } foreach (IList <IGPSPoint> gp in tr.GpsPoints()) { Color c = tr.ResultColor.LineNormal; c = Color.FromArgb(Data.Settings.RouteLineAlpha, c.R, c.G, c.B); results.Add(new TrailMapPolyline(gp, RouteWidth(), c, tr, s + cSeparator + results.Count)); } return(results); }
private EditTrailRow(TrailGPSLocation loc, TrailResult tr, int i) : this(loc) { this.m_resultPointIndex = i; if (tr != null && tr.TrailPointDateTime.Count > 0) { DateTime d = DateTime.MinValue; if (tr.TrailPointDateTime != null && tr.TrailPointDateTime.Count > m_resultPointIndex && m_resultPointIndex >= 0) { d = tr.TrailPointDateTime[m_resultPointIndex]; } SetDistance(tr, d); if (this.m_resultPointIndex < tr.SubResultInfo.Count) { this.m_diff = tr.PointDiff(this.m_resultPointIndex); } } }
public EditTrail(ITheme visualTheme, System.Globalization.CultureInfo culture, ActivityDetailPageControl page, IDailyActivityView view, TrailPointsLayer layer, bool addMode, bool copy, TrailResult tr) #endif : this(addMode, copy) { #if !ST_2_1 this.m_page = page; this.m_view = view; this.m_layer = layer; this.m_layer.TrailPoints = m_TrailToEdit.TrailLocations; #endif this.m_trailResult = tr; //It is possible that the trail result is not for the trail to edit (if more than one is selected) if (tr != null && tr.Trail != Controller.TrailController.Instance.PrimaryCurrentActivityTrail.Trail) { this.m_trailResult = null; } ThemeChanged(visualTheme); UICultureChanged(culture); }
private void SetDistance(TrailResult tr, DateTime d1) { //if (DateTime.MinValue == d1) //{ // //Try get the value from the track // if (null != this.TrailGPS.DateTime) // { // d1 = (DateTime)this.TrailGPS.DateTime; // } //} if (DateTime.MinValue != d1) { try { //Elapsed time/distance is for the activity m_distance = UnitUtil.Distance.ConvertFrom(tr.GetDistActivity(d1), tr.Activity); m_time = tr.GetTimeActivity(d1); m_elevation = tr.GetElevation(d1); } catch { } } }
void summaryList_SelectedItemsChanged(object sender, System.EventArgs e) { IList<UniqueRoutesResult> results = getListSelection(this.summaryList.SelectedItems); IDictionary<string, MapPolyline> routes = new Dictionary<string, MapPolyline>(); foreach (UniqueRoutesResult ur in results) { //Possibly limit no of Trails shown, it slows down (show complete Activities?) TrailResult tr = new TrailResult(ur); TrailMapPolyline m = new TrailMapPolyline(tr); m.Click += new MouseEventHandler(mapPoly_Click); routes.Add(m.key, m); } if (this.m_layer != null) { m_layer.TrailRoutes = routes; } }
public void AfterImport(IList added, IList updated) { //Only added, not updated foreach (object item in added) { if (item is IActivity) { IActivity activity = (IActivity)item; //Set for barometric devices only bool setEle = false; if (TrailsPlugin.Data.Settings.SetAdjustElevationAtImport) { foreach (string devName in Settings.BarometricDevices) { if (activity.Metadata.Source.Contains(devName)) { setEle = true; break; } } } if (setEle) { //Do not keep selection, sort find best Controller.TrailController.Instance.SetActivities(new List <IActivity> { activity }, false); foreach (ActivityTrail at in Controller.TrailController.Instance.OrderedTrails()) { if (at.Trail.IsSplits) { at.CalcResults(null); } if (at.Status == TrailOrderStatus.Match) { TrailResult tr = null; if (!at.Trail.IsCompleteActivity) { //Recalculate, to get "full" first result IList <TrailResultWrapper> ats = at.CalcTrailCompleteResult(activity); if (ats.Count > 0) { tr = ats[0].Result; } } else if (at.Results.Count > 0) { tr = at.Results[0].Result; } if (tr != null) { tr.SetDeviceElevation(true); break; } } } } } } }
//Note: IItemTrackSelectionInfo uses Activity distances, avoid... public TrailResultMarked(TrailResult tr, IValueRangeSeries<double> t) { trailResult = tr; selInfo.MarkedDistances = t; }
private static float[] GetChartResultFromDistResult(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, IValueRange <double> v) { //Note: Selecting in Route gives unpaused distance, but this should be handled in the selection if (xIsTime) { DateTime d1 = tr.GetDateTimeFromDistActivity(v.Lower); DateTime d2 = tr.GetDateTimeFromDistActivity(v.Upper); return(GetTimeChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, d1, d2)); } else { double t1 = tr.GetDistResultFromDistActivity(v.Lower); double t2 = tr.GetDistResultFromDistActivity(v.Upper); return(GetDistChartResultFromDistResult(isOffset, tr, ReferenceTrailResult, t1, t2)); } }
//Complete trail public TrailMapPolyline(TrailResult tr) : this(tr.GpsPoints(), UnitUtil.GetApplication().SystemPreferences.RouteSettings.RouteWidth, tr.TrailColor, tr) { }
//Mark all public TrailResultMarked(TrailResult tr) { trailResult = tr; selInfo.MarkedTimes = tr.getSelInfo(); selInfo.Activity = tr.Activity; }
public TrailResultMarked(TrailResult tr, IValueRangeSeries <DateTime> t) { this.trailResult = tr; this.selInfo.MarkedTimes = TrailsItemTrackSelectionInfo.excludePauses(t, tr.Pauses); this.selInfo.Activity = tr.Activity; }
public static float ChartResultConvert(bool xOldIsTime, bool xNewIsTime, bool isOffset, TrailResult newTr, TrailResult ReferenceTrailResult, float t) { if (float.IsNaN(t)) { return(t); } DateTime time = TrackUtil.GetDateTimeFromChartResult(xOldIsTime, isOffset, newTr, ReferenceTrailResult, t); float res = TrackUtil.GetChartResultFromDateTime(xNewIsTime, isOffset, newTr, ReferenceTrailResult, time); return(res); }
public static IValueRangeSeries <DateTime> GetDateTimeFromChartResult(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, IList <float[]> regions) { IValueRangeSeries <DateTime> t = new ValueRangeSeries <DateTime>(); foreach (float[] at in regions) { DateTime d1 = GetDateTimeFromChartResult(xIsTime, isOffset, tr, ReferenceTrailResult, at[0]); DateTime d2 = GetDateTimeFromChartResult(xIsTime, isOffset, tr, ReferenceTrailResult, at[1]); t.Add(new ValueRange <DateTime>(d1, d2)); } return(t); }
private TrailMapPolyline(IList<IGPSPoint> g, int w, Color c, TrailResult tr, string tkey) : this(g, w, c, tr) { m_key += tkey; }
/*************************************************/ //From result elapsed, get chart result //TBD: incorrect to result public static float GetChartResultsResyncOffset(bool xIsTime, TrailResult tr, TrailResult ReferenceTrailResult, float elapsed, out float nextElapsed) { float offset = 0; nextElapsed = float.MaxValue; if (Data.Settings.SyncChartAtTrailPoints && tr.Trail.TrailType == Trail.CalcType.TrailPoints) { IList <float> trElapsed; //IList<float> trOffset; IList <float> refElapsed; if (xIsTime) { trElapsed = tr.TrailPointTime0(ReferenceTrailResult); //trOffset = tr.TrailPointTimeOffset0(ReferenceTrailResult); refElapsed = ReferenceTrailResult.TrailPointTime0(ReferenceTrailResult); } else { trElapsed = tr.TrailPointDist0(ReferenceTrailResult); //trOffset = tr.TrailPointDistOffset0(ReferenceTrailResult); refElapsed = ReferenceTrailResult.TrailPointDist0(ReferenceTrailResult); } //If the result/reference has no laps, no offset if (trElapsed.Count <= 2 || refElapsed.Count <= 2) { return(offset); } int currOffsetIndex = 0; while (currOffsetIndex < trElapsed.Count && currOffsetIndex < refElapsed.Count && (float.IsNaN(trElapsed[currOffsetIndex]) || elapsed > trElapsed[currOffsetIndex])) { if (!float.IsNaN(trElapsed[currOffsetIndex]) && !float.IsNaN(refElapsed[currOffsetIndex])) { offset = refElapsed[currOffsetIndex] - trElapsed[currOffsetIndex]; //if (currOffsetIndex < trOffset.Count && !float.IsNaN(trOffset[currOffsetIndex])) //{ // offset += trOffset[currOffsetIndex]; //} } currOffsetIndex++; } //currOffsetIndex is at least one step over already while (currOffsetIndex < trElapsed.Count && currOffsetIndex < refElapsed.Count && (float.IsNaN(trElapsed[currOffsetIndex]) || float.IsNaN(refElapsed[currOffsetIndex]) || elapsed < trElapsed[currOffsetIndex])) { if (currOffsetIndex >= trElapsed.Count - 1 || currOffsetIndex >= refElapsed.Count - 1) { //Last point - no limitation nextElapsed = float.MaxValue; break; } else if (!float.IsNaN(trElapsed[currOffsetIndex]) && !float.IsNaN(refElapsed[currOffsetIndex])) { nextElapsed = refElapsed[currOffsetIndex]; } currOffsetIndex++; } } return(offset); }
internal static IList <float[]> GetChartResultFromActivity(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, IItemTrackSelectionInfo sel) { IList <float[]> result = new List <float[]>(); //Currently only one range but several regions in the chart can be selected //Only use one of the selections if (sel.MarkedTimes != null) { foreach (IValueRange <DateTime> v in sel.MarkedTimes) { result.Add(GetChartResultFromDateTime(xIsTime, isOffset, tr, ReferenceTrailResult, v)); } } else if (sel.MarkedDistances != null) { foreach (IValueRange <double> v in sel.MarkedDistances) { result.Add(GetChartResultFromDistResult(xIsTime, isOffset, tr, ReferenceTrailResult, v)); } } else if (sel.SelectedTime != null) { result.Add(GetChartResultFromDateTime(xIsTime, isOffset, tr, ReferenceTrailResult, sel.SelectedTime)); } else if (sel.SelectedDistance != null) { result.Add(GetChartResultFromDistResult(xIsTime, isOffset, tr, ReferenceTrailResult, sel.SelectedDistance)); } return(result); }
void summaryList_Click(object sender, System.EventArgs e) { #if !ST_2_1 //From Trails plugin if (sender is TreeList) { TreeList l = sender as TreeList; object row; TreeList.RowHitState hit; row = summaryList.RowHitTest(((MouseEventArgs)e).Location, out hit); if (row != null && hit == TreeList.RowHitState.Row) { UniqueRoutesResult utr = (UniqueRoutesResult)(row); bool colorSelected = false; if (hit != TreeList.RowHitState.PlusMinus) { int nStart = ((MouseEventArgs)e).X; int spos = l.Location.X;// +l.Parent.Location.X; for (int i = 0; i < l.Columns.Count; i++) { int epos = spos + l.Columns[i].Width; if (nStart > spos && nStart < epos) { if (l.Columns[i].Id == SummaryColumnIds.ActColor) { colorSelected = true; break; } } spos = epos; } } if (colorSelected) { ColorSelectorPopup cs = new ColorSelectorPopup(); cs.Width = 70; cs.ThemeChanged(m_visualTheme); cs.DesktopLocation = ((Control)sender).PointToScreen(((MouseEventArgs)e).Location); cs.Selected = utr.ActColor; m_ColorSelectorResult = utr; cs.ItemSelected += new ColorSelectorPopup.ItemSelectedEventHandler(cs_ItemSelected); cs.Show(); } else { bool isMatch = false; foreach (UniqueRoutesResult t in getListSelection(this.summaryList.SelectedItems)) { if (t == utr) { isMatch = true; break; } } IList<TrailResultMarked> aTrm = new List<TrailResultMarked>(); if (isMatch && m_refActivity != null) { IDictionary<IActivity, IList<PointInfo[]>> commonStretches = SimilarPoints; if (commonStretches.Count > 0 && commonStretches.ContainsKey(utr.Activity) && commonStretches[utr.Activity] != null && commonStretches[utr.Activity].Count > 0) { TrailResult tr = new TrailResult(utr); IItemTrackSelectionInfo[] i = CommonStretches.getSelInfo(new DateTime[] { utr.Activity.StartTime, m_refActivity.StartTime }, commonStretches[utr.Activity], true); ((TrailsItemTrackSelectionInfo)i[0]).Activity = utr.Activity; ((TrailsItemTrackSelectionInfo)i[1]).Activity = m_refActivity; aTrm.Add(new TrailResultMarked(tr, i[0].MarkedTimes)); aTrm.Add(new TrailResultMarked(tr, i[1].MarkedTimes)); } } this.MarkTrack(aTrm); } } } #endif }
public TrailResultMarked(TrailResult tr, IValueRangeSeries<DateTime> t) { trailResult = tr; selInfo.MarkedTimes = t; selInfo.Activity = tr.Activity; }
public static void ChartResultConvert(bool xOldIsTime, bool xNewIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, float[] t) { if (TrackUtil.AnyRangeOverlap(xOldIsTime, isOffset, tr, ReferenceTrailResult, t)) { t[0] = ChartResultConvert(xOldIsTime, xNewIsTime, isOffset, tr, ReferenceTrailResult, t[0]); t[1] = ChartResultConvert(xOldIsTime, xNewIsTime, isOffset, tr, ReferenceTrailResult, t[1]); } else { t[0] = float.NaN; t[1] = float.NaN; } }
public TrailResultMarked(TrailResult tr, IValueRange <DateTime> t) { this.trailResult = tr; this.selInfo.SelectedTime = t; //include pauses this.selInfo.Activity = tr.Activity; }
public static void ChartResultConvert(bool xOldIsTime, bool xNewIsTime, bool isOffset, TrailResult oldTr, TrailResult newTr, TrailResult ReferenceTrailResult, float[] t) { DateTime time0 = DateTime.MinValue; if (!float.IsNaN(t[0])) { time0 = TrackUtil.GetDateTimeFromChartResult(xOldIsTime, isOffset, oldTr, ReferenceTrailResult, t[0]); } DateTime time1 = DateTime.MinValue; if (!float.IsNaN(t[1])) { time1 = TrackUtil.GetDateTimeFromChartResult(xOldIsTime, isOffset, oldTr, ReferenceTrailResult, t[1]); } if (TrackUtil.AnyOverlap(time0, time1, newTr.StartTime, newTr.EndTime)) { t[0] = TrackUtil.GetChartResultFromDateTime(xNewIsTime, isOffset, newTr, ReferenceTrailResult, time0); t[1] = TrackUtil.GetChartResultFromDateTime(xNewIsTime, isOffset, newTr, ReferenceTrailResult, time1); } else { t[0] = float.NaN; t[1] = float.NaN; } }
public TrailResultMarked(TrailResult tr, IItemTrackSelectionInfo t) { trailResult = tr; selInfo.SetFromSelection(t, tr.Activity); }
public InsertValues(TrailResult result) : this(result.StartTime, result.EndTime, result.Pauses) { this.points = result.SubResultInfo.Points; }
/****************************************************/ public static bool AnyRangeOverlap(bool isTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, float[] t) { float[] t2 = GetChartResultFromDateTime(isTime, isOffset, tr, ReferenceTrailResult, new ValueRange <DateTime>(tr.StartTime, tr.EndTime)); return(TrackUtil.AnyRangeOverlap(t, t2[0], t2[1])); }
private static float[] GetChartResultFromDateTime(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, IValueRange <DateTime> v) { DateTime d1 = v.Lower; DateTime d2 = v.Upper; if (xIsTime) { return(GetTimeChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, d1, d2)); } else { double t1 = tr.GetDistResult(d1); double t2 = tr.GetDistResult(d2); return(GetDistChartResultFromDistResult(isOffset, tr, ReferenceTrailResult, t1, t2)); } }
public static DateTime GetDateTimeFromChartResult(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, float t) { DateTime dateTime; float xOffset = tr.GetXOffset(xIsTime, ReferenceTrailResult); if (!xIsTime) { xOffset = (float)TrackUtil.DistanceConvertFrom(xOffset, ReferenceTrailResult); } t -= xOffset; if (isOffset) { float nextElapsed; t -= GetChartResultsResyncOffset(xIsTime, tr, ReferenceTrailResult, t, out nextElapsed); } if (xIsTime) { dateTime = tr.GetDateTimeFromTimeResult(t); } else { dateTime = tr.GetDateTimeFromDistResult(TrackUtil.DistanceConvertTo(t, ReferenceTrailResult)); } return(dateTime); }
private TrailMapPolyline(IList<IGPSPoint> g, int w, Color c, TrailResult tr) : base(g, w, c) { m_trailResult = tr; m_key = tr.Activity + ":" + tr.Order; }