public AggregationView()
{
InitializeComponent();
// Design time!
if (DesignerProperties.GetIsInDesignMode(this))
{
var appConfiguration = new CapFrameXConfiguration();
var recordDataProvider = new RecordDataProvider(new RecordDirectoryObserver(appConfiguration,
new LoggerFactory().CreateLogger <RecordDirectoryObserver>()), appConfiguration, new LoggerFactory().CreateLogger <RecordDataProvider>());
DataContext = new AggregationViewModel(new FrametimeStatisticProvider(appConfiguration), recordDataProvider, new EventAggregator(), appConfiguration);
}
(DataContext as AggregationViewModel)
.OutlierFlagStream
.Throttle(TimeSpan.FromMilliseconds(100))
.Subscribe(OnOutlierFlagsChanged);
}
public StateView()
{
InitializeComponent();
if (DesignerProperties.GetIsInDesignMode(this))
{
var appConfiguration = new CapFrameXConfiguration();
var statisticProvider = new FrametimeStatisticProvider(appConfiguration);
var recordDirectoryObserver = new RecordDirectoryObserver(appConfiguration,
new LoggerFactory().CreateLogger <RecordDirectoryObserver>());
var recordDataProvider = new RecordDataProvider(recordDirectoryObserver, appConfiguration,
new LoggerFactory().CreateLogger <RecordDataProvider>());
var overlayEntryProvider = new OverlayEntryProvider();
var appVersionProvider = new AppVersionProvider();
var webVersionProvider = new WebVersionProvider();
DataContext = new StateViewModel(new RecordDirectoryObserver(appConfiguration,
new LoggerFactory().CreateLogger <RecordDirectoryObserver>()),
new EventAggregator(), appConfiguration, new PresentMonCaptureService(),
new OverlayService(statisticProvider, recordDataProvider, overlayEntryProvider, appConfiguration,
new LoggerFactory().CreateLogger <OverlayService>()),
new UpdateCheck(appVersionProvider, webVersionProvider), appVersionProvider, webVersionProvider);
}
}
private List <string> GetAdjustedCaptureData()
{
if (!_captureData.Any())
{
return(Enumerable.Empty <string>().ToList());
}
var processName = RecordDataProvider.GetProcessNameFromDataLine(_captureData.First());
var startTimeWithOffset = RecordDataProvider.GetStartTimeFromDataLine(_captureData.First());
var stopwatchTime = (_timestampStopCapture - _timestampStartCapture) / 1000d;
if (string.IsNullOrWhiteSpace(CaptureTimeString))
{
CaptureTimeString = "0";
AddLoggerEntry($"Wrong capture time string. Value will be set to default (0).");
}
var definedTime = Convert.ToInt32(CaptureTimeString);
bool autoTermination = Convert.ToInt32(CaptureTimeString) > 0;
if (autoTermination)
{
if (stopwatchTime < definedTime - 0.2 && stopwatchTime > 0)
{
autoTermination = false;
}
}
var filteredArchive = _captureDataArchive.Where(line => RecordDataProvider.GetProcessNameFromDataLine(line) == processName).ToList();
AddLoggerEntry($"Using archive with {filteredArchive.Count} frames.");
if (!filteredArchive.Any())
{
AddLoggerEntry($"Empty archive. No file will be written.");
return(Enumerable.Empty <string>().ToList());
}
// Distinct archive and live stream
var lastArchiveTime = RecordDataProvider.GetStartTimeFromDataLine(filteredArchive.Last());
int distinctIndex = 0;
for (int i = 0; i < _captureData.Count; i++)
{
if (RecordDataProvider.GetStartTimeFromDataLine(_captureData[i]) <= lastArchiveTime)
{
distinctIndex++;
}
else
{
break;
}
}
if (distinctIndex == 0)
{
return(null);
}
var unionCaptureData = filteredArchive.Concat(_captureData.Skip(distinctIndex)).ToList();
var unionCaptureDataStartTime = RecordDataProvider.GetStartTimeFromDataLine(unionCaptureData.First());
var unionCaptureDataEndTime = RecordDataProvider.GetStartTimeFromDataLine(unionCaptureData.Last());
AddLoggerEntry($"Length captured data + archive in sec: " +
$"{ Math.Round(unionCaptureDataEndTime - unionCaptureDataStartTime, 2)}");
var captureInterval = new List <string>();
double startTime = 0;
// find first dataline that fits start of valid interval
for (int i = 0; i < unionCaptureData.Count - 1; i++)
{
var currentQpcTime = RecordDataProvider.GetQpcTimeFromDataLine(unionCaptureData[i + 1]);
if (currentQpcTime >= _qpcTimeStart)
{
startTime = RecordDataProvider.GetStartTimeFromDataLine(unionCaptureData[i]);
break;
}
}
if (startTime == 0)
{
AddLoggerEntry($"Start time is invalid. Error while evaluating QPCTime start.");
return(Enumerable.Empty <string>().ToList());
}
if (!autoTermination)
{
for (int i = 0; i < unionCaptureData.Count; i++)
{
var currentqpcTime = RecordDataProvider.GetQpcTimeFromDataLine(unionCaptureData[i]);
var currentTime = RecordDataProvider.GetStartTimeFromDataLine(unionCaptureData[i]);
if (currentqpcTime >= _qpcTimeStart && currentTime - startTime <= stopwatchTime)
{
captureInterval.Add(unionCaptureData[i]);
}
}
if (!captureInterval.Any())
{
AddLoggerEntry($"Empty capture interval. Error while evaluating start and end time.");
return(Enumerable.Empty <string>().ToList());
}
}
else
{
AddLoggerEntry($"Length captured data QPCTime start to end with buffer in sec: " +
$"{ Math.Round(unionCaptureDataEndTime - startTime, 2)}");
for (int i = 0; i < unionCaptureData.Count; i++)
{
var currentStartTime = RecordDataProvider.GetStartTimeFromDataLine(unionCaptureData[i]);
if (currentStartTime >= startTime && currentStartTime - startTime <= definedTime)
{
captureInterval.Add(unionCaptureData[i]);
}
}
}
return(captureInterval);
}
public void AddRunToHistory(List <string> captureData)
{
var frametimes = captureData.Select(line =>
RecordDataProvider.GetFrameTimeFromDataLine(line)).ToList();
if (RunHistoryCount == _numberOfRuns)
{
if (!_runHistoryOutlierFlags.All(x => x == false) &&
_appConfiguration.OutlierHandling == EOutlierHandling.Replace.ConvertToString())
{
var historyDefault = Enumerable.Repeat("N/A", _numberOfRuns).ToList();
var validRuns = _runHistory.Where((run, i) => _runHistoryOutlierFlags[i] == false).ToList();
for (int i = 0; i < validRuns.Count; i++)
{
historyDefault[i] = validRuns[i];
}
var validCaptureData = _captureDataHistory.Where((run, i) => _runHistoryOutlierFlags[i] == false);
var validFrametimes = _frametimeHistory.Where((run, i) => _runHistoryOutlierFlags[i] == false);
var validMetricAnalysis = _metricAnalysis.Where((run, i) => _runHistoryOutlierFlags[i] == false);
_runHistory = historyDefault.ToList();
_captureDataHistory = validCaptureData.ToList();
_frametimeHistory = validFrametimes.ToList();
_metricAnalysis = validMetricAnalysis.ToList();
// local reset
_runHistoryOutlierFlags = Enumerable.Repeat(false, _numberOfRuns).ToArray();
SetRunHistory(_runHistory.ToArray());
SetRunHistoryAggregation(string.Empty);
SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
}
else
{
ResetHistory();
}
}
if (RunHistoryCount < _numberOfRuns)
{
// metric history
var currentAnalysis = _statisticProvider.GetMetricAnalysis(frametimes, SecondMetric, ThirdMetric);
_metricAnalysis.Add(currentAnalysis);
_runHistory[RunHistoryCount] = currentAnalysis.ResultString;
SetRunHistory(_runHistory.ToArray());
// capture data history
_captureDataHistory.Add(captureData);
// frametime history
_frametimeHistory.Add(frametimes);
if (_appConfiguration.UseAggregation &&
RunHistoryCount == _numberOfRuns)
{
_runHistoryOutlierFlags = _statisticProvider
.GetOutlierAnalysis(_metricAnalysis,
_appConfiguration.RelatedMetricOverlay,
_appConfiguration.OutlierPercentageOverlay);
SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
if ((_runHistoryOutlierFlags.All(x => x == false) &&
_appConfiguration.OutlierHandling == EOutlierHandling.Replace.ConvertToString()) ||
_appConfiguration.OutlierHandling == EOutlierHandling.Ignore.ConvertToString())
{
SetRunHistoryAggregation(GetAggregation());
// write aggregated file
Task.Run(async() =>
{
await SetTaskDelayOffset().ContinueWith(_ =>
{
_recordDataProvider
.SaveAggregatedPresentData(_captureDataHistory);
}, CancellationToken.None, TaskContinuationOptions.RunContinuationsAsynchronously, TaskScheduler.Default);
});
}
}
}
}
