void DataSeriesCollectionPropertyChanged()
{
if (_dataSeriesCollectionObserver != null) _dataSeriesCollectionObserver.UnregisterHandler(DataSeriesCollectionChanged);
if (DataSeriesCollection == null) return;
if (_dataSeriesCollectionObserver == null) _dataSeriesCollectionObserver = new CollectionObserver(DataSeriesCollection);
_dataSeriesCollectionObserver.RegisterHandler(DataSeriesCollectionChanged);
}
protected SeriesViewModelBase()
{
_propertyObserver = new PropertyObserver<SeriesViewModelBase>(this)
.RegisterHandler(d => d.SeriesData, SeriesDataChanged)
.RegisterHandler(d => d.ItemToPoint, ProcessSeriesData)
.RegisterHandler(d => d.XAxis, XAxisChanged)
.RegisterHandler(d => d.YAxis, YAxisChanged);
_pointsObserver = new CollectionObserver(Points).RegisterHandler(PointsCollectionChanged);
}
public AnalysisPointsNode(Scenario scenario)
{
_propertyObserver = new PropertyObserver<AnalysisPointsNode>(this)
.RegisterHandler(p => p.Scenario,
() =>
{
if (_collectionObserver != null) _collectionObserver.UnregisterHandler(AnalysisPointCollectionChanged);
else _collectionObserver = new CollectionObserver(Scenario.AnalysisPoints);
_collectionObserver.RegisterHandler(AnalysisPointCollectionChanged);
}
);
Scenario = scenario;
CheckForErrors();
}
public LineSeriesViewModel()
{
_propertyObserver = new PropertyObserver<LineSeriesViewModel>(this)
.RegisterHandler(d => d.MarkerType, MarkerPropertiesChanged)
.RegisterHandler(d => d.MarkerStrokeThickness, MarkerPropertiesChanged)
.RegisterHandler(d => d.MarkerSize, MarkerPropertiesChanged)
.RegisterHandler(d => d.MarkerStroke, MarkerPropertiesChanged)
.RegisterHandler(d => d.LineStroke, LinePropertiesChanged)
.RegisterHandler(d => d.LineFill, LinePropertiesChanged)
.RegisterHandler(d => d.LineStrokeDashArray, LinePropertiesChanged)
.RegisterHandler(d => d.LineStrokeThickness, LinePropertiesChanged);
_pointsObserver = new CollectionObserver(Points).RegisterHandler(PointsCollectionChanged);
LegendItems.Add(new LegendItemViewModel(this));
}
public SimulationExposuresViewModel(ObservableCollection<HistogramBinsViewModel> histogramBinsViewModels)
{
HistogramBinsViewModels = histogramBinsViewModels;
_propertyObserver = new PropertyObserver<SimulationExposuresViewModel>(this)
.RegisterHandler(p => p.ActualHeight, () => RowHeight = (ActualHeight / HistogramBinsViewModels.Count) - 10);
_collectionObserver = new CollectionObserver(HistogramBinsViewModels)
.RegisterHandler((s, e) =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (HistogramBinsViewModel vm in e.NewItems)
{
_axisLegendCollectionObservers.Add(new CollectionObserver(vm.EnergyViewModel.LegendItems).RegisterHandler(LegendItemsCollectionChangedHandler));
_axisLegendCollectionObservers.Add(new CollectionObserver(vm.PressureViewModel.LegendItems).RegisterHandler(LegendItemsCollectionChangedHandler));
}
break;
}
});
}
protected MultipleBarSeriesBase()
{
_propertyObserver = new PropertyObserver<SeriesViewModelBase>(this)
.RegisterHandler(d => d.XAxis,
() =>
{
if (XAxis == null) return;
_xAxisObserver = new PropertyObserver<DataAxisViewModel>(XAxis)
.RegisterHandler(d => d.ValueToPosition, RenderShapes);
foreach (var barSeries in BarSeriesCollection) barSeries.XAxis = XAxis;
RenderShapes();
})
.RegisterHandler(d => d.YAxis,
() =>
{
if (YAxis == null) return;
_yAxisObserver = new PropertyObserver<DataAxisViewModel>(YAxis)
.RegisterHandler(d => d.ValueToPosition, RenderShapes);
foreach (var barSeries in BarSeriesCollection) barSeries.YAxis = YAxis;
RenderShapes();
});
_seriesObserver = new CollectionObserver(BarSeriesCollection)
.RegisterHandler(BarSeriesCollectionChanged);
}
public async Task Analyze(Dispatcher dispatcher, IUIVisualizerService visualizer)
{
if (SelectedModeIds == null) throw new NullReferenceException("SelectedModeIds may not be null");
if (SelectedSpeciesGuids == null) throw new NullReferenceException("SelectedSpeciesGuids may not be null");
if (SelectedModeIds.Count == 0) throw new InvalidOperationException("SelectedModeIds may not be an empty list");
if (SelectedSpeciesGuids.Count == 0) throw new InvalidOperationException("SelectedSpeciesGuids may not be an empty list");
if (double.IsNaN(StartBinValue) || (StartBinValue < 0)) throw new InvalidOperationException("StartBinValue must be a positive value");
if (double.IsNaN(BinWidth) || (BinWidth < 0)) throw new InvalidOperationException("BinWidth must be a positive value");
if (BinCount <= 0) throw new InvalidOperationException("BinCount must be a positive value");
if (FilterStartTime.Ticks < 0) throw new InvalidOperationException("FilterStartTime must be a positive value");
if (FilterEndTime.Ticks < 0) throw new InvalidOperationException("FilterEndTime must be a positive value");
if (FilterEndTime.Ticks <= FilterStartTime.Ticks) throw new InvalidOperationException("FilterEndTime must be greater than FilterStartTime");
SimulationLog simulationLog = null;
try
{
simulationLog = SimulationLog.Open(LogFilename);
if (FilterEndTime.Ticks > (simulationLog.TimeStepSize.Ticks * simulationLog.TimeStepCount)) throw new InvalidOperationException("FilterEndTime cannot be greater than the last time step in the simulation");
for (var speciesIndex = 0; speciesIndex < simulationLog.SpeciesRecords.Count; speciesIndex++) GuidToColorMap.Add(simulationLog.SpeciesRecords[speciesIndex].Guid, BarColors[speciesIndex % BarColors.Count]);
Func<ActorExposureRecord, bool> modeFilter = record =>
{
var speciesRecord = simulationLog.RecordFromActorID(record.ActorID) as SpeciesNameGuid;
return speciesRecord != null && SelectedModeIds.Contains(record.ModeID);
};
Func<ActorExposureRecord, bool> speciesFilter = record =>
{
var speciesRecord = simulationLog.RecordFromActorID(record.ActorID) as SpeciesNameGuid;
return speciesRecord != null && SelectedSpeciesGuids.Contains(speciesRecord.Guid);
};
var histogramBinsViewModels = new ObservableCollection<HistogramBinsViewModel>();
var scenarioName = simulationLog.ScenarioRecord.Name;
var simulationStartTime = simulationLog.StartTime;
SimulationExposuresViewModel viewModel = null;
dispatcher.InvokeIfRequired(() =>
{
viewModel = new SimulationExposuresViewModel(histogramBinsViewModels) { WindowTitle = string.Format("Scenario: {0} simulated on {1} (Processing)", scenarioName, simulationStartTime) };
Window = visualizer.ShowWindow("SimulationExposuresView", viewModel);
});
var modeThresholdHistogram = new ModeThresholdHistogram(this, simulationLog, StartBinValue, BinWidth, BinCount, modeFilter, speciesFilter);
_modeBinsCollectionObserver = new CollectionObserver(modeThresholdHistogram.GroupedExposures.Groups)
.RegisterHandler((s, e) =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (GroupedExposuresHistogram histogram in e.NewItems) histogramBinsViewModels.Add(new HistogramBinsViewModel(histogram));
break;
}
});
var timeStepIndex = 0;
Task<bool> processTask = null;
foreach (var timeStepRecord in simulationLog.Where(timeStepRecord => timeStepRecord.StartTime >= FilterStartTime && FilterEndTime >= timeStepRecord.StartTime))
{
timeStepRecord.ReadAll();
timeStepIndex++;
var record = timeStepRecord;
if (processTask != null) await processTask;
processTask = modeThresholdHistogram.Process(record, dispatcher);
if (timeStepIndex % 10 == 0) UpdateHistogramDisplay();
}
if (processTask != null) await processTask;
UpdateHistogramDisplay();
viewModel.WindowTitle = string.Format("Scenario: {0} simulated on {1}", scenarioName, simulationStartTime);
Debug.WriteLine("Finished processing simulation exposure file");
}
finally
{
if (simulationLog != null) simulationLog.Close();
}
}
void PerformAnalysis()
{
var filterStartTime = _filterStartTime;
var filterEndTime = _filterEndTime;
var selectedTimeRange = SelectedTimeRange;
Task<bool> processTask = null;
var selectedModeIds = (from mode in AvailableModes
where mode.IsSelected
select ((ModeNameGuid)mode.NameGuidRecord).ActorID).ToList();
var selectedSpeciesGuids = (from species in AvailableSpecies
where species.IsSelected
select species.NameGuidRecord.Guid).ToList();
Func<ActorExposureRecord, bool> modeFilter = record =>
{
var speciesRecord = SimulationLog.RecordFromActorID(record.ActorID) as SpeciesNameGuid;
return speciesRecord != null && selectedModeIds.Contains(record.ModeID);
};
Func<ActorExposureRecord, bool> speciesFilter = record =>
{
var speciesRecord = SimulationLog.RecordFromActorID(record.ActorID) as SpeciesNameGuid;
return speciesRecord != null && selectedSpeciesGuids.Contains(speciesRecord.Guid);
};
var histogramBinsViewModels = new ObservableCollection<HistogramBinsViewModel>();
var viewModel = new SimulationExposuresViewModel(histogramBinsViewModels) { WindowTitle = "Test" };
_dispatcher.InvokeIfRequired(() => OpenWindows.Add(_visualizer.ShowWindow("SimulationExposuresView", viewModel)));
var modeThresholdHistogram = new ModeThresholdHistogram(this, SimulationLog, StartBinValue, BinWidth, BinCount, modeFilter, speciesFilter);
_modeBinsCollectionObserver = new CollectionObserver(modeThresholdHistogram.GroupedExposures.Groups)
.RegisterHandler((s, e) =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (GroupedExposuresHistogram histogram in e.NewItems) histogramBinsViewModels.Add(new HistogramBinsViewModel(histogram));
break;
}
});
var timeStepIndex = 0;
foreach (var timeStepRecord in SimulationLog.Where(timeStepRecord => !selectedTimeRange || (timeStepRecord.StartTime >= filterStartTime && filterEndTime >= timeStepRecord.StartTime)))
{
timeStepRecord.ReadAll();
timeStepIndex++;
var record = timeStepRecord;
if (processTask != null) processTask.Wait();
processTask = modeThresholdHistogram.Process(record, _dispatcher);
//if (timeStepIndex % 10 == 0) UpdateHistogramDisplay();
}
if (processTask != null) processTask.Wait();
UpdateHistogramDisplay();
Debug.WriteLine("Finished processing simulation exposure file");
}
void SeriesDataChanged()
{
Points.Clear();
ProcessSeriesData();
if (SeriesData == null || !(SeriesData is INotifyCollectionChanged)) return;
var series = (INotifyCollectionChanged)SeriesData;
if (_seriesDataObserver == null) _seriesDataObserver = new CollectionObserver(series).RegisterHandler(SeriesDataCollectionChanged);
else
{
_seriesDataObserver.UnregisterHandler(SeriesDataCollectionChanged);
_seriesDataObserver.RegisterHandler(SeriesDataCollectionChanged);
}
}
void AxisMarkersPropertyChanged()
{
if (AxisType == AxisType.Logarithmic) throw new InvalidOperationException("Cannot set AxisTicks on a Logarithmic axis");
if (_markersObserver != null)
{
_markersObserver.UnregisterHandler(AxisMarkersCollectionChanged);
_markersObserver = null;
}
if (AxisTicks == null) return;
_markersObserver = new CollectionObserver(AxisMarkers);
_markersObserver.RegisterHandler(AxisMarkersCollectionChanged);
}
