working on continuum analysis window (9044bdb8) · Commits · INAF / DotNET / Apps / Uwp / INAF.Apps.Uwp.LabDataManager

INAF.Apps.Uwp.SLabDataManager/Charts/SpectraContainer.cs

+3 −235

Original line number	Diff line number	Diff line
		@@ -16,17 +16,11 @@ using SpectrumModel = INAF.Apps.Uwp.SLabDataManager.Models.Spectrum.SpectrumMode

		namespace INAF.Apps.Uwp.SLabDataManager.Charts
		{
		public class SpectraContainer : ObservableObject
		public class SpectraContainer : SpectraContainerBase
		{
		public SpectraContainer(IServiceProvider serviceProvider,
		Logger logger)
		{
		SpectrumAlignmentConfig = serviceProvider.GetRequiredService<SpectrumAlignmentConfigModel>();

		SelectedRefBand = serviceProvider.GetRequiredService<SelectedRefBand>();

		init();
		}
		Logger logger) : base(serviceProvider, logger)
		{ }

		private void Spectrum_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
		{
		@@ -36,134 +30,6 @@ namespace INAF.Apps.Uwp.SLabDataManager.Charts
		});
		}

		#region properties
		public bool IsAlignedSpectrumSaved { get; set; }

		private bool isAnySummaryUpdated;
		public bool IsAnySummaryUpdated
		{
		get { return isAnySummaryUpdated; }
		set { SetProperty(ref isAnySummaryUpdated, value); }
		}

		private bool isAnySpectrumLoaded;
		public bool IsAnySpectrumLoaded
		{
		get { return isAnySpectrumLoaded; }
		set
		{
		SetProperty(ref isAnySpectrumLoaded, value);
		isAnySpectrumLoaded = false; // reset value to make it working @ the next spectrum loading
		}
		}

		private bool isAnySpectrumUpdated;
		public bool IsAnySpectrumUpdated
		{
		get { return isAnySpectrumUpdated; }
		set
		{
		if (SetProperty(ref isAnySpectrumUpdated, value))
		isAnySpectrumUpdated = false; // reset value to make it working @ the next spectrum loading
		}
		}

		private bool isSpectrumAligned;
		public bool IsSpectrumAligned
		{
		get { return isSpectrumAligned; }
		set { SetProperty(ref isSpectrumAligned, value); }
		}

		private bool isSpectrumContinuumRemoved;
		public bool IsSpectrumContinuumRemoved
		{
		get { return isSpectrumContinuumRemoved; }
		set { SetProperty(ref isSpectrumContinuumRemoved, value); }
		}

		private bool isChartUpdateLayoutRequired;
		public bool IsChartUpdateLayoutRequired
		{
		get { return isChartUpdateLayoutRequired; }
		set { SetProperty(ref isChartUpdateLayoutRequired, value); }
		}

		private ObservableCollection<SpectrumModel> spectra;
		public ObservableCollection<SpectrumModel> Spectra
		{
		get { return spectra; }
		private set { SetProperty(ref spectra, value); }
		}

		public SelectedRefBand SelectedRefBand { get; private set; }

		public SpectrumAlignmentConfigModel SpectrumAlignmentConfig { get; private set; }

		private ObservableCollection<SpectrumSummaryModel> summaries;
		public ObservableCollection<SpectrumSummaryModel> Summaries
		{
		get { return summaries; }
		private set { SetProperty(ref summaries, value); }
		}

		#region spectrums min/max
		private AxisBoundariesModel xAxisBoundaries;
		public AxisBoundariesModel XAxisBoundaries
		{
		get { return xAxisBoundaries; }
		private set { SetProperty(ref xAxisBoundaries, value); }
		}

		private AxisBoundariesModel yAxisBoundaries;
		public AxisBoundariesModel YAxisBoundaries
		{
		get { return yAxisBoundaries; }
		private set { SetProperty(ref yAxisBoundaries, value); }
		}

		public string YAxisTitle { get; private set; }

		#region x axis major step
		private double selectedXAxisMajorStep;
		public double SelectedXAxisMajorStep
		{
		get { return selectedXAxisMajorStep; }
		private set { SetProperty(ref selectedXAxisMajorStep, value); }
		}

		public List<double> XAxisMajorStepValues { get; private set; }

		private double selectedYAxisMajorStep;
		public double SelectedYAxisMajorStep
		{
		get { return selectedYAxisMajorStep; }
		private set { SetProperty(ref selectedYAxisMajorStep, value); }
		}
		#endregion
		#endregion
		#endregion

		public void clear()
		{
		Spectra.Clear();
		}

		private void init()
		{
		Spectra = new ObservableCollection<SpectrumModel>();
		Summaries = new ObservableCollection<SpectrumSummaryModel>();

		IsAlignedSpectrumSaved = false;
		IsAnySpectrumLoaded = false;
		IsSpectrumAligned = false;
		IsChartUpdateLayoutRequired = false;

		XAxisMajorStepValues = new List<double>(2);
		XAxisMajorStepValues.Add(Constants.Constants.X_AXIS_MAJOR_STEP_0DOT1);
		XAxisMajorStepValues.Add(Constants.Constants.X_AXIS_MAJOR_STEP_100);
		}

		public void raiseIsAnySpectrumLoaded()
		{
		IsAnySpectrumLoaded = true;
		@@ -177,31 +43,6 @@ namespace INAF.Apps.Uwp.SLabDataManager.Charts
		await updateBoundariesAsync();
		}

		//private void setXAxisMajorStep(WavelengthMeasureUnit wavelengthMeasureUnit)
		//{
		// switch (wavelengthMeasureUnit)
		// {
		// case WavelengthMeasureUnit.Nanometers:
		// SelectedXAxisMajorStep = XAxisMajorStepValues.FirstOrDefault(x => x == Constants.Constants.X_AXIS_MAJOR_STEP_100);
		// break;
		// case WavelengthMeasureUnit.Microns:
		// SelectedXAxisMajorStep = XAxisMajorStepValues.FirstOrDefault(x => x == Constants.Constants.X_AXIS_MAJOR_STEP_0DOT1);
		// break;
		// }
		//}

		public void setYAxisTitle(string title)
		{
		YAxisTitle = title;
		}

		public void switchXAxisMeasureUnit(WavelengthMeasureUnit wavelengthMeasureUnit)
		{
		Spectra.All(x => { x.switchToMeasureUnit(wavelengthMeasureUnit); return true; });
		XAxisBoundaries.switchToMeasureUnit(wavelengthMeasureUnit);
		//setXAxisMajorStep(wavelengthMeasureUnit);
		}

		#region spectra
		public async Task addOrUpdateSpectrumAsync(SpectrumModel spectrum)
		{
		@@ -304,78 +145,5 @@ namespace INAF.Apps.Uwp.SLabDataManager.Charts
		return Summaries.FirstOrDefault(x => x.Type == spectrumType);
		}
		#endregion

		#region boundaries
		private async Task<(double xMin, double xMax, double yMin, double yMax)> getSpectrumAxesBoundariesAsync()
		{
		List<Task> tasks = new List<Task>();

		double xMin = 0d;
		double xMax = 0d;
		double yMin = 0d;
		double yMax = 0d;
		tasks.Add(Task.Run(() =>
		{
		List<double> xvalues = new List<double>();
		foreach (var spectrum in spectra)
		{
		if (spectrum.IsVisible)
		xvalues.AddRange(spectrum.Elements.Select(x => x.X));
		}

		if (xvalues.Count > 0)
		{
		(double xMin, double xMax) xresult = xvalues.GetBoundaries();
		xMin = xresult.xMin;
		xMax = xresult.xMax;
		}
		}));
		tasks.Add(Task.Run(() =>
		{
		List<double> yvalues = new List<double>();
		foreach (var spectrum in spectra)
		{
		if (spectrum.IsVisible)
		yvalues.AddRange(spectrum.Elements.Select(x => x.Y));
		}
		//(double yMin, double yMax) yresult = yvalues.GetBoundaries();
		//yMin = yresult.yMin;
		//yMax = yresult.yMax;
		if (yvalues.Count > 0)
		{
		yMin = yvalues.Min() * 0.9;
		yMax = yvalues.Max() * 1.1;
		}
		}));

		await Task.WhenAll(tasks);

		System.Diagnostics.Debug.WriteLine($"x: [{xMin},{xMax}], y: [{yMin},{yMax}]");

		return (xMin, xMax, yMin, yMax);
		}

		public void raiseIsUpdateLayoutRequired()
		{
		IsChartUpdateLayoutRequired = true;
		isChartUpdateLayoutRequired = false;
		}

		private async Task setBoundariesAsync()
		{
		(double xMin, double xMax, double yMin, double yMax) result = await getSpectrumAxesBoundariesAsync();

		XAxisBoundaries = new AxisBoundariesModel("x", result.xMin, result.xMax, spectra[0].Elements[0].MeasureUnit);
		YAxisBoundaries = new AxisBoundariesModel("y", result.yMin, result.yMax);
		}

		public async Task updateBoundariesAsync()
		{
		(double xMin, double xMax, double yMin, double yMax) result = await getSpectrumAxesBoundariesAsync();

		XAxisBoundaries.updateAxisBoundaries(result.xMin, result.xMax);
		YAxisBoundaries.updateAxisBoundaries(result.yMin, result.yMax);
		}
		#endregion
		}
		}

INAF.Apps.Uwp.SLabDataManager/Charts/SpectraContainerBase.cs

0 → 100644

+244 −0

Original line number	Diff line number	Diff line
		using INAF.Apps.Uwp.SLabDataManager.Models;
		using INAF.Libraries.NetStandard.ScienceModels.Extensions;
		using INAF.Libraries.NetStandard.ScienceModels.Spectra;
		using INAF.Libraries.Uwp.Logging;
		using Microsoft.Extensions.DependencyInjection;
		using Microsoft.Toolkit.Mvvm.ComponentModel;
		using System;
		using System.Collections.Generic;
		using System.Collections.ObjectModel;
		using System.Linq;
		using System.Threading.Tasks;
		using static INAF.Libraries.NetStandard.ScienceModels.Enums.Enums;
		using SpectrumModel = INAF.Apps.Uwp.SLabDataManager.Models.Spectrum.SpectrumModel;

		namespace INAF.Apps.Uwp.SLabDataManager.Charts
		{
		public class SpectraContainerBase : ObservableObject
		{
		public SpectraContainerBase(IServiceProvider serviceProvider,
		Logger logger)
		{
		SpectrumAlignmentConfig = serviceProvider.GetRequiredService<SpectrumAlignmentConfigModel>();

		SelectedRefBand = serviceProvider.GetRequiredService<SelectedRefBand>();

		init();
		}



		#region properties
		public bool IsAlignedSpectrumSaved { get; set; }

		protected bool isAnySummaryUpdated;
		public bool IsAnySummaryUpdated
		{
		get { return isAnySummaryUpdated; }
		set { SetProperty(ref isAnySummaryUpdated, value); }
		}

		protected bool isAnySpectrumLoaded;
		public bool IsAnySpectrumLoaded
		{
		get { return isAnySpectrumLoaded; }
		set
		{
		SetProperty(ref isAnySpectrumLoaded, value);
		isAnySpectrumLoaded = false; // reset value to make it working @ the next spectrum loading
		}
		}

		protected bool isAnySpectrumUpdated;
		public bool IsAnySpectrumUpdated
		{
		get { return isAnySpectrumUpdated; }
		set
		{
		if (SetProperty(ref isAnySpectrumUpdated, value))
		isAnySpectrumUpdated = false; // reset value to make it working @ the next spectrum loading
		}
		}

		protected bool isSpectrumAligned;
		public bool IsSpectrumAligned
		{
		get { return isSpectrumAligned; }
		set { SetProperty(ref isSpectrumAligned, value); }
		}

		protected bool isSpectrumContinuumRemoved;
		public bool IsSpectrumContinuumRemoved
		{
		get { return isSpectrumContinuumRemoved; }
		set { SetProperty(ref isSpectrumContinuumRemoved, value); }
		}

		protected bool isChartUpdateLayoutRequired;
		public bool IsChartUpdateLayoutRequired
		{
		get { return isChartUpdateLayoutRequired; }
		set { SetProperty(ref isChartUpdateLayoutRequired, value); }
		}

		protected ObservableCollection<SpectrumModel> spectra;
		public ObservableCollection<SpectrumModel> Spectra
		{
		get { return spectra; }
		protected set { SetProperty(ref spectra, value); }
		}

		public SelectedRefBand SelectedRefBand { get; private set; }

		public SpectrumAlignmentConfigModel SpectrumAlignmentConfig { get; protected set; }

		protected ObservableCollection<SpectrumSummaryModel> summaries;
		public ObservableCollection<SpectrumSummaryModel> Summaries
		{
		get { return summaries; }
		protected set { SetProperty(ref summaries, value); }
		}

		#region spectrums min/max
		protected AxisBoundariesModel xAxisBoundaries;
		public AxisBoundariesModel XAxisBoundaries
		{
		get { return xAxisBoundaries; }
		protected set { SetProperty(ref xAxisBoundaries, value); }
		}

		protected AxisBoundariesModel yAxisBoundaries;
		public AxisBoundariesModel YAxisBoundaries
		{
		get { return yAxisBoundaries; }
		protected set { SetProperty(ref yAxisBoundaries, value); }
		}

		public string YAxisTitle { get; private set; }

		#region x axis major step
		protected double selectedXAxisMajorStep;
		public double SelectedXAxisMajorStep
		{
		get { return selectedXAxisMajorStep; }
		protected set { SetProperty(ref selectedXAxisMajorStep, value); }
		}

		public List<double> XAxisMajorStepValues { get; protected set; }

		protected double selectedYAxisMajorStep;
		public double SelectedYAxisMajorStep
		{
		get { return selectedYAxisMajorStep; }
		protected set { SetProperty(ref selectedYAxisMajorStep, value); }
		}
		#endregion
		#endregion
		#endregion

		public void clear()
		{
		Spectra.Clear();
		}

		protected void init()
		{
		Spectra = new ObservableCollection<SpectrumModel>();
		Summaries = new ObservableCollection<SpectrumSummaryModel>();

		IsAlignedSpectrumSaved = false;
		IsAnySpectrumLoaded = false;
		IsSpectrumAligned = false;
		IsChartUpdateLayoutRequired = false;

		XAxisMajorStepValues = new List<double>(2);
		XAxisMajorStepValues.Add(Constants.Constants.X_AXIS_MAJOR_STEP_0DOT1);
		XAxisMajorStepValues.Add(Constants.Constants.X_AXIS_MAJOR_STEP_100);
		}

		public void setYAxisTitle(string title)
		{
		YAxisTitle = title;
		}

		public void switchXAxisMeasureUnit(WavelengthMeasureUnit wavelengthMeasureUnit)
		{
		Spectra.All(x => { x.switchToMeasureUnit(wavelengthMeasureUnit); return true; });
		XAxisBoundaries.switchToMeasureUnit(wavelengthMeasureUnit);
		//setXAxisMajorStep(wavelengthMeasureUnit);
		}

		#region boundaries
		protected async Task<(double xMin, double xMax, double yMin, double yMax)> getSpectrumAxesBoundariesAsync()
		{
		List<Task> tasks = new List<Task>();

		double xMin = 0d;
		double xMax = 0d;
		double yMin = 0d;
		double yMax = 0d;
		tasks.Add(Task.Run(() =>
		{
		List<double> xvalues = new List<double>();
		foreach (var spectrum in spectra)
		{
		if (spectrum.IsVisible)
		xvalues.AddRange(spectrum.Elements.Select(x => x.X));
		}

		if (xvalues.Count > 0)
		{
		(double xMin, double xMax) xresult = xvalues.GetBoundaries();
		xMin = xresult.xMin;
		xMax = xresult.xMax;
		}
		}));
		tasks.Add(Task.Run(() =>
		{
		List<double> yvalues = new List<double>();
		foreach (var spectrum in spectra)
		{
		if (spectrum.IsVisible)
		yvalues.AddRange(spectrum.Elements.Select(x => x.Y));
		}
		//(double yMin, double yMax) yresult = yvalues.GetBoundaries();
		//yMin = yresult.yMin;
		//yMax = yresult.yMax;
		if (yvalues.Count > 0)
		{
		yMin = yvalues.Min() * 0.9;
		yMax = yvalues.Max() * 1.1;
		}
		}));

		await Task.WhenAll(tasks);

		System.Diagnostics.Debug.WriteLine($"x: [{xMin},{xMax}], y: [{yMin},{yMax}]");

		return (xMin, xMax, yMin, yMax);
		}

		public void raiseIsUpdateLayoutRequired()
		{
		IsChartUpdateLayoutRequired = true;
		isChartUpdateLayoutRequired = false;
		}

		protected async Task setBoundariesAsync()
		{
		(double xMin, double xMax, double yMin, double yMax) result = await getSpectrumAxesBoundariesAsync();

		XAxisBoundaries = new AxisBoundariesModel("x", result.xMin, result.xMax, spectra[0].Elements[0].MeasureUnit);
		YAxisBoundaries = new AxisBoundariesModel("y", result.yMin, result.yMax);
		}

		public async Task updateBoundariesAsync()
		{
		(double xMin, double xMax, double yMin, double yMax) result = await getSpectrumAxesBoundariesAsync();

		XAxisBoundaries.updateAxisBoundaries(result.xMin, result.xMax);
		YAxisBoundaries.updateAxisBoundaries(result.yMin, result.yMax);
		}
		#endregion
		}
		}

INAF.Apps.Uwp.SLabDataManager/Helpers/UI/Chart/LegendItemExtension.cs

0 → 100644

+24 −0

Original line number	Diff line number	Diff line
		using System.ComponentModel;
		using System.Runtime.CompilerServices;

		namespace INAF.Apps.Uwp.SLabDataManager.Helpers.UI.Chart
		{
		public class LegendItemExtension : Telerik.UI.Xaml.Controls.Primitives.LegendItem, INotifyPropertyChanged
		{
		private double opacity;

		public double Opacity
		{
		get { return opacity; }
		set { opacity = value; RaisePropertyChanged(nameof(Opacity)); }
		}

		#region INotifyPropertyChanged
		public event PropertyChangedEventHandler PropertyChanged;
		protected void RaisePropertyChanged([CallerMemberName] string propertyName = "")
		{
		PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
		}
		#endregion
		}
		}

INAF.Apps.Uwp.SLabDataManager/Helpers/UI/Chart/SpectrumProcessingHelper.cs

+100 −5

Original line number	Diff line number	Diff line
		using INAF.Apps.Uwp.SLabDataManager.Charts;
		using INAF.Apps.Uwp.SLabDataManager.Extensions;
		using INAF.Apps.Uwp.SLabDataManager.Models;
		using INAF.Apps.Uwp.SLabDataManager.Models.Fit;
		using INAF.Apps.Uwp.SLabDataManager.ViewModels;
		using INAF.Libraries.NetStandard.AlgLib;
		using INAF.Libraries.NetStandard.AlgLib.Models;
		using INAF.Libraries.NetStandard.ScienceModels.Spectra;
		using INAF.Libraries.Uwp.Logging;
		using Microsoft.Extensions.DependencyInjection;
		using Microsoft.Toolkit.Mvvm.ComponentModel;
		using Microsoft.Toolkit.Mvvm.DependencyInjection;
		using System;
		using System.Collections.Generic;
		using System.Linq;
		using System.Reflection;
		using System.Threading.Tasks;
		using static INAF.Libraries.NetStandard.SLabCommonModels.Enums.Enums;
		using SpectrumModel = INAF.Apps.Uwp.SLabDataManager.Models.Spectrum.SpectrumModel;
		@@ -333,18 +337,109 @@ namespace INAF.Apps.Uwp.SLabDataManager.Helpers.UI.Chart
		var rawSpectrum = workingItems.SpectraContainer.tryGetSpectrumOfType(SpectrumType.Raw);

		double[] xValues = rawSpectrum.getXvalues();
		var spline1dinterpolant = splineFitHelper.buildSpline1Dinterpolant(xValues, rawSpectrum.getYvalues());
		//var spline1dinterpolant = splineFitHelper.buildSpline1DFitInterpolant(xValues, rawSpectrum.getYvalues());

		string exMsg = string.Empty;
		await Task.Run(() =>
		{
		//try
		//{
		// int xValuesNum = xValues.Length;

		// for (int i = 0; i < xValuesNum; i++)
		// {
		// continuumFittedSpectrum.Elements[i].updateY(splineFitHelper.getSpline1dValue(xValues[i], spline1dinterpolant));
		// }
		//}
		//catch (Exception ex)
		//{
		// exMsg = ex.Message;
		// logger.Write<SpectrumProcessingHelper>($"{nameof(fitContinuumAsync)} - ex: {ex.Message}", Serilog.Events.LogEventLevel.Error);
		//}
		});

		if (string.IsNullOrEmpty(exMsg))
		{
		//Ioc.Default.GetRequiredService<ChartViewModel>().IsAddingPointsForContinuumRemovalAllowed = false;
		//workingItems.SpectraContainer.IsSpectrumContinuumRemoved = true;
		await workingItems.SpectraContainer.addOrUpdateSpectrumAsync(continuumFittedSpectrum);

		await workingItems.SpectraContainer.updateBoundariesAsync();
		}
		else
		{
		DialogMessage = exMsg;
		raiseIsDialogRequired();
		}
		}

		private T fitContinuum<T>(FitMethodModel fitMethod,
		double[] x,
		double[] y,
		double? parameterValue = null)
		{
		Type type = typeof(SplineFitHelper);

		MethodInfo methodInfo = type.GetMethod(fitMethod.MethodName);
		if (methodInfo == null)
		return default;

		object result = null;

		ParameterInfo[] parameters = methodInfo.GetParameters();
		object classInstance = Activator.CreateInstance(type, null);

		if (parameters.Length == 0)
		{
		// This works fine
		result = methodInfo.Invoke(classInstance, null);
		}
		else
		{
		List<object> parametersList = new List<object>(new object[] { x, y });
		if (parameterValue != null)
		parametersList.Add((double)parameterValue);

		result = methodInfo.Invoke(classInstance, parametersList.ToArray());
		}

		return (T)result;
		}

		public async Task fitContinuumProcedureAsync(FitMethodModel fitMethod,
		double[] x,
		double[] y,
		double? parameterValue = null)
		{
		SpectrumModel continuumFittedSpectrum = cloneSpectrum(SpectrumType.Continuum);
		if (continuumFittedSpectrum == null)
		{
		UpdateUIHelper.UpdateUIAsync(() =>
		{
		DialogMessageType = DialogMessageType.Warning;
		DialogMessage = "NoAlignedSpectrumAvailableWarningMessage".GetText();
		raiseIsDialogRequired();
		});
		return;
		}

		var result = fitContinuum<Spline1dFitResult>(fitMethod, x, y, parameterValue);
		if (result is Spline1dFitCubicResult)
		{

		}

		string exMsg = string.Empty;
		await Task.Run(() =>
		{
		try
		{
		int xValuesNum = xValues.Length;
		var splineFitHelper = serviceProvider.GetRequiredService<SplineFitHelper>();
		int xValuesNum = x.Length;

		for (int i = 0; i < xValuesNum; i++)
		{
		continuumFittedSpectrum.Elements[i].updateY(splineFitHelper.getSpline1dValue(xValues[i], spline1dinterpolant));
		continuumFittedSpectrum.Elements[i].updateY(splineFitHelper.getSpline1dValue(x[i], result.Spline1dinterpolant));
		}
		}
		catch (Exception ex)
		@@ -358,9 +453,9 @@ namespace INAF.Apps.Uwp.SLabDataManager.Helpers.UI.Chart
		{
		//Ioc.Default.GetRequiredService<ChartViewModel>().IsAddingPointsForContinuumRemovalAllowed = false;
		//workingItems.SpectraContainer.IsSpectrumContinuumRemoved = true;
		await workingItems.SpectraContainer.addOrUpdateSpectrumAsync(continuumFittedSpectrum);
		await workingItems.ContinuumSpectraContainer.addOrUpdateSpectrumAsync(continuumFittedSpectrum);

		await workingItems.SpectraContainer.updateBoundariesAsync();
		await workingItems.ContinuumSpectraContainer.updateBoundariesAsync();
		}
		else
		{

INAF.Apps.Uwp.SLabDataManager/Helpers/UI/LegendItemsHelper.cs

0 → 100644

+38 −0

File added.

Preview size limit exceeded, changes collapsed.