private bool TrySaveLap(ILapInfo lapInfo)
        {
            try
            {
                LapSummaryDto lapSummaryDto = CreateLapSummary(lapInfo);

                TimedTelemetrySnapshot fistSnapshotsByDistance = lapInfo.LapTelemetryInfo.TimedTelemetrySnapshots.Snapshots.First(x => x.PlayerData.LapDistance < _sessionInfoDto.LayoutLength * 0.5);

                LapTelemetryDto lapTelemetryDto = new LapTelemetryDto()
                {
                    LapSummary = lapSummaryDto,
                    DataPoints = lapInfo.LapTelemetryInfo.TimedTelemetrySnapshots.Snapshots.Skip(lapInfo.LapTelemetryInfo.TimedTelemetrySnapshots.Snapshots.ToList().IndexOf(fistSnapshotsByDistance)).ToList()
                };


                Interpolate(lapTelemetryDto, lapTelemetryDto.DataPoints.First().SimulatorSourceInfo.TelemetryInfo.RequiresDistanceInterpolation, lapTelemetryDto.DataPoints.First().SimulatorSourceInfo.TelemetryInfo.RequiresPositionInterpolation);

                LapSummaryDto previousLapInfo = _sessionInfoDto.LapsSummary.FirstOrDefault(x => x.LapNumber == lapSummaryDto.LapNumber);
                if (previousLapInfo != null)
                {
                    _sessionInfoDto.LapsSummary.Remove(previousLapInfo);
                }

                _sessionInfoDto.LapsSummary.Add(lapSummaryDto);

                _telemetryRepository.SaveRecentSessionInformation(_sessionInfoDto, SessionIdentifier);
                _telemetryRepository.SaveRecentSessionLap(lapTelemetryDto, SessionIdentifier);
                return(true);
            }
            catch (Exception ex)
            {
                Logger.Error(ex, "Uanble to Save Telemetry");
                return(false);
            }
        }
        public TelemetryStoryboard Create(LapTelemetryDto lapTelemetryDto)
        {
            TelemetryStoryboard   telemetryStoryboard = new TelemetryStoryboard(lapTelemetryDto.LapSummary);
            List <TelemetryFrame> telemetryFrames     = new List <TelemetryFrame>();
            TelemetryFrame        previousFrame       = null;

            foreach (TimedTelemetrySnapshot timedTelemetrySnapshot in lapTelemetryDto.DataPoints.OrderBy(x => x.LapTimeSeconds))
            {
                TelemetryFrame currentFrame = new TelemetryFrame(timedTelemetrySnapshot, telemetryStoryboard)
                {
                    PreviousFrame = previousFrame
                };
                if (previousFrame == null)
                {
                    telemetryStoryboard.FirstFrame = currentFrame;
                }
                else
                {
                    previousFrame.NextFrame = currentFrame;
                }
                telemetryFrames.Add(currentFrame);
                previousFrame = currentFrame;
            }

            telemetryStoryboard.TelemetryFrames = telemetryFrames.AsReadOnly();
            telemetryStoryboard.LastFrame       = previousFrame;
            return(telemetryStoryboard);
        }
Esempio n. 3
0
        protected override void UpdateYMaximum(LapTelemetryDto lapTelemetry)
        {
            double newYMax = lapTelemetry.TimedTelemetrySnapshots.Max(x => x.PlayerData?.CarInfo?.OverallDownForce?.GetValueInUnits(ForceUnits) ?? 0.0);

            if (newYMax > YMaximum)
            {
                YMaximum = newYMax;
            }
        }
Esempio n. 4
0
        protected override void UpdateYMaximum(LapTelemetryDto lapTelemetry)
        {
            double newMax = lapTelemetry.TimedTelemetrySnapshots.Max(x => x.PlayerData.Speed.GetValueInUnits(VelocityUnits)) * 1.1;

            if (newMax > YMaximum)
            {
                YMaximum = newMax;
            }
        }
        private LapTelemetryDto LoadLapTelemetryDto(string lapId, LapSummaryDto lapSummaryDto)
        {
            LapTelemetryDto lapTelemetryDto = _telemetryRepository.LoadLapTelemetryDtoFromAnySession(lapSummaryDto);

            _missingTelemetryFillers.ForEach(x => x.SetSimulator(lapSummaryDto.Simulator));
            lapTelemetryDto.Accept(_missingTelemetryFillers.OfType <ITimedTelemetrySnapshotVisitor>().ToArray());
            FillCustomDisplayName(lapTelemetryDto.LapSummary);
            return(lapTelemetryDto);
        }
        protected override void UpdateYMaximum(LapTelemetryDto lapTelemetry)
        {
            double newMax = XAxisKind == XAxisKind.LapTime ? Distance.FromMeters(lapTelemetry.TimedTelemetrySnapshots.Max(x => x.PlayerData.LapDistance)).GetByUnit(DistanceUnits) : lapTelemetry.LapSummary.LapTimeSeconds * 1.1;

            if (newMax > YMaximum)
            {
                YMaximum = newMax;
            }
        }
        protected override void UpdateYMaximum(LapTelemetryDto lapTelemetry)
        {
            double max = lapTelemetry.TimedTelemetrySnapshots.Max(x => x.InputInfo.WheelAngle);

            if (max > YMaximum)
            {
                YMinimum = -max;
                YMaximum = max;
            }
        }
        protected override void UpdateYMaximum(LapTelemetryDto lapTelemetry)
        {
            if (_maxRake != 0)
            {
                YMaximum = _maxRake;
            }

            if (_minRake < double.MaxValue)
            {
                YMinimum = _minRake;
            }
        }
        protected override void UpdateYMaximum(LapTelemetryDto lapTelemetry)
        {
            double newMax = lapTelemetry.TimedTelemetrySnapshots.Max(x => x.PlayerData.CarInfo.EngineRpm) * 1.1;
            double newMin = lapTelemetry.TimedTelemetrySnapshots.Min(x => x.PlayerData.CarInfo.EngineRpm) * 0.9;

            if (newMax > YMaximum)
            {
                YMaximum = newMax;
            }

            if (newMin < YMinimum || YMinimum == 0)
            {
                YMinimum = newMin;
            }
        }
        private void Interpolate(LapTelemetryDto lapTelemetryDto, bool interpolateDistance, bool interpolateLocation)
        {
            if (!interpolateDistance && !interpolateLocation)
            {
                return;
            }

            TimedTelemetrySnapshot        lastNonInterpolatedSnapshot = null;
            List <TimedTelemetrySnapshot> snapshotsToInterpolate      = new List <TimedTelemetrySnapshot>();

            foreach (TimedTelemetrySnapshot timedTelemetrySnapshot in lapTelemetryDto.DataPoints)
            {
                if (!timedTelemetrySnapshot.SimulatorSourceInfo.TimeInterpolated && lastNonInterpolatedSnapshot == null)
                {
                    lastNonInterpolatedSnapshot = timedTelemetrySnapshot;
                    continue;
                }

                if (timedTelemetrySnapshot.SimulatorSourceInfo.TimeInterpolated)
                {
                    snapshotsToInterpolate.Add(timedTelemetrySnapshot);
                    continue;
                }

                double tickDistance = (timedTelemetrySnapshot.PlayerData.LapDistance - lastNonInterpolatedSnapshot.PlayerData.LapDistance) / snapshotsToInterpolate.Count;
                double tickX        = (timedTelemetrySnapshot.PlayerData.WorldPosition.X.InMeters - lastNonInterpolatedSnapshot.PlayerData.WorldPosition.X.InMeters) / snapshotsToInterpolate.Count;
                double tickY        = (timedTelemetrySnapshot.PlayerData.WorldPosition.Y.InMeters - lastNonInterpolatedSnapshot.PlayerData.WorldPosition.Y.InMeters) / snapshotsToInterpolate.Count;
                double tickZ        = (timedTelemetrySnapshot.PlayerData.WorldPosition.Z.InMeters - lastNonInterpolatedSnapshot.PlayerData.WorldPosition.Z.InMeters) / snapshotsToInterpolate.Count;

                for (int i = 0; i < snapshotsToInterpolate.Count; i++)
                {
                    if (interpolateDistance)
                    {
                        snapshotsToInterpolate[i].PlayerData.LapDistance = lastNonInterpolatedSnapshot.PlayerData.LapDistance + tickDistance * i;
                    }

                    if (interpolateLocation)
                    {
                        snapshotsToInterpolate[i].PlayerData.WorldPosition = new Point3D(
                            Distance.FromMeters(lastNonInterpolatedSnapshot.PlayerData.WorldPosition.X.InMeters + tickX * i),
                            Distance.FromMeters(lastNonInterpolatedSnapshot.PlayerData.WorldPosition.Y.InMeters + tickY * i),
                            Distance.FromMeters(lastNonInterpolatedSnapshot.PlayerData.WorldPosition.Z.InMeters + tickZ * i)
                            );
                    }
                }
            }
        }
        public async Task <LapTelemetryDto> LoadLap(LapSummaryDto lapSummaryDto)
        {
            try
            {
                AddToActiveLapJob();
                LapTelemetryDto lapTelemetryDto = null;
                await Task.Run(() => lapTelemetryDto = _cachedTelemetries.GetOrAdd(lapSummaryDto.Id, LoadLapTelemetryDto, lapSummaryDto));

                _telemetryViewsSynchronization.NotifyLapLoaded(lapTelemetryDto);
                return(lapTelemetryDto);
            }
            catch (Exception ex)
            {
                Logger.Error(ex, "Error while loading lap telemetry");
                return(null);
            }
            finally
            {
                RemoveFromActiveLapJob();
            }
        }
 protected override void UpdateYMaximum(LapTelemetryDto lapTelemetry)
 {
     YMinimum = -3;
     YMaximum = 3;
 }
Esempio n. 13
0
 public LapTelemetryArgs(LapTelemetryDto lapTelemetry)
 {
     LapTelemetry = lapTelemetry;
 }
        public void NotifyLapLoaded(LapTelemetryDto lapTelemetryDto)
        {
            LapTelemetryArgs lapTelemetryArgs = new LapTelemetryArgs(lapTelemetryDto);

            LapLoaded?.Invoke(this, lapTelemetryArgs);
        }
Esempio n. 15
0
 protected override void UpdateYMaximum(LapTelemetryDto lapTelemetry)
 {
     YMaximum = 7;
 }
 private void AddLapLoadedLap(LapTelemetryDto lapTelemetryDto)
 {
     _loadedTelemetries.Add(lapTelemetryDto.LapSummary.Id, _telemetryStoryBoardFactory.Create(lapTelemetryDto));
 }