Esempio n. 1
0
        private FrameFieldValues GetFrameFieldValues(int lapIdx, int frameIdx, int fieldIdx)
        {
            FrameFieldValues ffv = new FrameFieldValues();

            var lapValues = Model.GetLapFieldValues(lapIdx, fieldIdx).ToList();

            ffv.Value  = lapValues[frameIdx];
            ffv.LapMin = lapValues.Min();
            ffv.LapMax = lapValues.Max();
            ffv.LapAvg = lapValues.Average();

            var series = Model.GetSeries(fieldIdx);

            if (series.ShowMaximumWarning && series.MaxWarning.HasValue)
            {
                ffv.MaxWarning = ffv.Value >= series.MaxWarning.Value;
            }

            if (series.ShowMinimumWarning && series.MinWarning.HasValue)
            {
                ffv.MinWarning = ffv.Value <= series.MinWarning.Value;
            }

            return(ffv);
        }
Esempio n. 2
0
        private void UpdateSeriesListValues(int frameIdx)
        {
            if (Model == null)
            {
                return;
            }

            if (!Model.HasValues)
            {
                return;
            }

            if (frameIdx < 0 || frameIdx > Model.FrameCount)
            {
                return;
            }

            for (int i = 0; i < Model.SeriesCount; i++)
            {
                var value = Model.GetValue(_selectedLap, frameIdx, i);
                lvFieldList.Items[i].SubItems[(int)FieldListColumns.Value].Text = value.ToString(Model.GetSeries(i).Format);

                FrameFieldValues ffv = GetFrameFieldValues(_selectedLap, frameIdx, i);

                lvFieldList.Items[i].SubItems[(int)FieldListColumns.Value].Text = ffv.Value.ToString(Model.GetSeries(i).Format);

                if (ffv.MinWarning)
                {
                    lvFieldList.Items[i].SubItems[(int)FieldListColumns.Warning].BackColor = Color.Orange;
                }
                else if (ffv.MaxWarning)
                {
                    lvFieldList.Items[i].SubItems[(int)FieldListColumns.Warning].BackColor = Color.Red;
                }
                else
                {
                    lvFieldList.Items[i].SubItems[(int)FieldListColumns.Warning].BackColor = Color.Black;
                }

                lvFieldList.Items[i].SubItems[(int)FieldListColumns.LapMin].Text =
                    Model.GetSeries(i).ShowLapMinimum ? ffv.Value.ToString(Model.GetSeries(i).Format) : String.Empty;

                lvFieldList.Items[i].SubItems[(int)FieldListColumns.LapMax].Text =
                    Model.GetSeries(i).ShowLapMaximum ? ffv.Value.ToString(Model.GetSeries(i).Format) : String.Empty;

                lvFieldList.Items[i].SubItems[(int)FieldListColumns.LapAvg].Text =
                    Model.GetSeries(i).ShowLapAverage ? ffv.Value.ToString(Model.GetSeries(i).Format) : String.Empty;
            }

            _selectedFrame = frameIdx;

            this.Refresh();
        }
        private FrameFieldValues GetFrameFieldValues(SummaryColumnFlags flags, int lapIdx, int frameIdx, int fieldIdx, float?minWarning, float?maxWarning)
        {
            IEnumerable <TelemetryValues> lapFieldValues = TelemetryData.GetLapFieldValues(lapIdx, fieldIdx).ToList();

            FrameFieldValues ffv;

            if (lapFieldValues.Count() == 0)
            {
                ffv = new FrameFieldValues(false);
            }
            else
            {
                ffv = new FrameFieldValues(true);

                ffv.Value = lapFieldValues.FirstOrDefault(v => v.FrameIdx == frameIdx).Value.GetValueOrDefault();

                IEnumerable <float> lapValues = lapFieldValues.Select(v => v.Value.GetValueOrDefault());

                var lapMin = lapValues.Min();
                var lapMax = lapValues.Max();

                if (flags.HasFlag(SummaryColumnFlags.LapMin))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.LapMin, lapMin);
                }

                if (flags.HasFlag(SummaryColumnFlags.LapMax))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.LapMax, lapMax);
                }

                if (flags.HasFlag(SummaryColumnFlags.LapDelta))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.LapDelta, lapMax - lapMin);
                }

                if (flags.HasFlag(SummaryColumnFlags.LapMode))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.LapMode, lapValues.Mode());
                }

                if (flags.HasFlag(SummaryColumnFlags.LapAvg))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.LapAvg, lapValues.Average());
                }

                if (flags.HasFlag(SummaryColumnFlags.LapStdDev))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.LapStdDev, lapValues.StandardDeviation());
                }

                IEnumerable <TelemetryValues> sessionFieldValues = TelemetryData.GetSessionFieldValues(fieldIdx);

                IEnumerable <float> sessionValues = sessionFieldValues.Select(v => v.Value.GetValueOrDefault());

                var sessionMin = sessionValues.Min();
                var sessionMax = sessionValues.Max();

                if (flags.HasFlag(SummaryColumnFlags.SessionMin))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.SessionMin, sessionMin);
                }

                if (flags.HasFlag(SummaryColumnFlags.SessionMax))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.SessionMax, sessionMax);
                }

                if (flags.HasFlag(SummaryColumnFlags.SessionDelta))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.SessionDelta, sessionMax - sessionMin);
                }

                if (flags.HasFlag(SummaryColumnFlags.SessionMode))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.SessionMode, sessionValues.Mode());
                }

                if (flags.HasFlag(SummaryColumnFlags.SessionAvg))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.SessionAvg, sessionValues.Average());
                }

                if (flags.HasFlag(SummaryColumnFlags.SessionStdDev))
                {
                    ffv.SummaryValues.Add(SummaryColumnFlags.SessionStdDev, sessionValues.StandardDeviation());
                }

                if (maxWarning.HasValue)
                {
                    ffv.MaxWarning = ffv.Value >= maxWarning.Value;
                }

                if (minWarning.HasValue)
                {
                    ffv.MinWarning = ffv.Value <= minWarning.Value;
                }
            }

            return(ffv);
        }
        /// <summary>
        /// Updates the value columns in the listview from the selected frame data.
        /// </summary>
        /// <param name="frameIdx"></param>
        private void UpdateSeriesListValues(int frameIdx)
        {
            if (!(TelemetryData?.HasValues).GetValueOrDefault(false))
            {
                // default settings - clear out all columns except field name and unit
                foreach (ILineGraphSeries series in Model.SeriesCollection)
                {
                    ListViewItem listItem = lvFieldList.Items[series.FieldIndex];

                    for (int i = 1; i < lvFieldList.Columns.Count - 1; i++)
                    {
                        listItem.SubItems[i].Text = String.Empty;
                    }
                }
            }
            else
            {
                // display telemetry values
                foreach (ILineGraphSeries series in Model.SeriesCollection)
                {
                    ListViewItem listItem = lvFieldList.Items[series.FieldIndex];

                    float minWarning = series.ShowMinimumWarning ?
                                       series.MinWarning
                            : 0;

                    float maxWarning = series.ShowMaximumWarning ?
                                       series.MaxWarning
                            : 0;

                    FrameFieldValues frameFieldValues = GetFrameFieldValues(
                        series.SummaryColumnFlags,
                        _selectedLapIdx,
                        frameIdx,
                        series.FieldIndex,
                        minWarning,
                        maxWarning);

                    if (frameFieldValues.HasValues)
                    {
                        listItem.SubItems[(int)FieldListColumns.Value].Text = frameFieldValues.Value.ToString(series.Format);

                        if (frameFieldValues.MinWarning)
                        {
                            listItem.ImageIndex = MinWarningImageIndex;
                        }
                        else if (frameFieldValues.MaxWarning)
                        {
                            listItem.ImageIndex = MaxWarningImageIndex;
                        }
                        else
                        {
                            listItem.ImageIndex = NoWarningImageIndex;
                        }

                        Array fieldColumns = Enum.GetValues(typeof(FieldListColumns));

                        for (int i = 2; i < fieldColumns.GetLength(0) - 1; i++)
                        {
                            FieldListColumns   fieldColumnsEnumValue  = (FieldListColumns)fieldColumns.GetValue(i);
                            SummaryColumnFlags summaryColumnFlagValue = fieldColumnsEnumValue.GetSummaryFieldColumn();

                            listItem.SubItems[(int)fieldColumnsEnumValue].Text =
                                series.SummaryColumnFlags.HasFlag(summaryColumnFlagValue) ? frameFieldValues.SummaryValues[summaryColumnFlagValue].ToString(series.Format) : MissingSummaryValueDisplay;
                        }
                    }
                }
            }

            ResizeSeriesListColumns();
        }