code refactoring for ChartViewModel; fix for smoothing panel

                .AddSingleton<SettingsHelper>()

                .AddSingleton<SmoothingBoundariesContainer>()

                .AddSingleton<SpectraContainer>()

                .AddSingleton<SpectrumAlignmentConfigModel>()

                .AddSingleton<AlignmentViewModel>()

                .AddSingleton<SpectrumChartOptionsModel>()

                .AddSingleton<StorageItemsSettingsHelper>()

                .AddSingleton<StorageItemsAccessHelper>()

using INAF.Apps.Uwp.Charts;

using INAF.Apps.Uwp.SLabDataManager.Models;

using INAF.Apps.Uwp.SLabDataManager.ViewModels.UserControlViewModels;

using INAF.Libraries.Uwp.Logging;

using Microsoft.Extensions.DependencyInjection;

using System;

                switchXAxisMeasureUnit(spectrumChartOptions.SelectedWavelengthMeasureUnit);

                await Task.Delay(TimeSpan.FromMilliseconds(300));

                SpectrumAlignmentConfig.switchToMeasureUnit(spectrumChartOptions.SelectedWavelengthMeasureUnit);

                AlignmentViewModel.switchToMeasureUnit(spectrumChartOptions.SelectedWavelengthMeasureUnit);

                SelectedRefBand.switchToMeasureUnit(spectrumChartOptions.SelectedWavelengthMeasureUnit);

                IsWorkInProgress = false;

        public SelectedRefBand SelectedRefBand { get; protected set; }

        public SpectrumAlignmentConfigModel SpectrumAlignmentConfig { get; protected set; }

        public AlignmentViewModel AlignmentViewModel { get; protected set; }

        public SpectrumType SelectedSpectrumType { get; protected set; }

        {

            base.init();

            SpectrumAlignmentConfig = serviceProvider.GetRequiredService<SpectrumAlignmentConfigModel>();

            AlignmentViewModel = serviceProvider.GetRequiredService<AlignmentViewModel>();

            SelectedRefBand = serviceProvider.GetRequiredService<SelectedRefBand>();

        public void createCartesianGridLineAnnotations(RadCartesianChart chart,

                                                       bool areSeparatorsVisible)

        {

            foreach (var separator in workingItems.SpectraContainer.SpectrumAlignmentConfig.WavelengthSeparators)

            foreach (var separator in workingItems.SpectraContainer.AlignmentViewModel.WavelengthSeparators)

                chart.Annotations.Add(getAnnotation(chart, separator, areSeparatorsVisible));

            chart.UpdateLayout();

            };

            annotation.SetBinding(CartesianGridLineAnnotation.ValueProperty, new Binding() { Path = new PropertyPath("CurrentValue"), Source = separator, Mode = BindingMode.OneWay });

            annotation.SetBinding(CartesianGridLineAnnotation.LabelProperty, new Binding() { Path = new PropertyPath("CurrentValue"), Source = separator, Mode = BindingMode.OneWay });

            annotation.SetBinding(CartesianGridLineAnnotation.VisibilityProperty, new Binding() { Path = new PropertyPath("AreSeparatorsVisible"), Source = workingItems.SpectraContainer.SpectrumAlignmentConfig, Converter = new BoolToVisibilityConverter(), Mode = BindingMode.OneWay });

            annotation.SetBinding(CartesianGridLineAnnotation.VisibilityProperty, new Binding() { Path = new PropertyPath("AreSeparatorsVisible"), Source = workingItems.SpectraContainer.AlignmentViewModel, Converter = new BoolToVisibilityConverter(), Mode = BindingMode.OneWay });

            return annotation;

        }

        #endregion

using INAF.Apps.Uwp.SLabDataManager.Models;

using INAF.Apps.Uwp.SLabDataManager.Models.Fit;

using INAF.Apps.Uwp.SLabDataManager.Models.Processing;

using INAF.Apps.Uwp.SLabDataManager.ViewModels.UserControlViewModels;

using INAF.Libraries.NetStandard.Math.Fit.Linear;

using INAF.Libraries.NetStandard.Math.Fit.Spline;

using INAF.Libraries.NetStandard.ScienceModels.Spectra;

    {

        private readonly IServiceProvider serviceProvider;

        private readonly LinearFitHelper linearFitHelper;

        private readonly SpectrumAlignmentConfigModel spectrumAlignmentConfig;

        private readonly AlignmentViewModel alignmentViewModel;

        private readonly SelectedRefBand selectedRefBand;

        private readonly WorkingItemsModel workingItems;

        private readonly Logger logger;

        public SpectrumProcessingHelper(IServiceProvider serviceProvider,

                                        LinearFitHelper linearFitHelper,

                                        WorkingItemsModel workingItems,

                                        SpectrumAlignmentConfigModel spectrumAlignmentConfig,

                                        AlignmentViewModel alignmentViewModel,

                                        SelectedRefBand selectedRefBand,

                                        Logger logger)

        {

            this.serviceProvider = serviceProvider;

            this.linearFitHelper = linearFitHelper;

            this.workingItems = workingItems;

            this.spectrumAlignmentConfig = spectrumAlignmentConfig;

            this.alignmentViewModel = alignmentViewModel;

            this.selectedRefBand = selectedRefBand;

            this.logger = logger;

        }

                    }

                    /* retrieve the reference segment and calculate the mean values at the borders of the segment for aligning other segments */

                    var refLowSeparator = spectrumAlignmentConfig.WavelengthSeparators.FirstOrDefault(x => x.CurrentValue >= selectedRefBand.XMin && x.CurrentValue <= selectedRefBand.XMax);

                    var refHighSeparator = spectrumAlignmentConfig.WavelengthSeparators.FirstOrDefault(x => x.CurrentValue > refLowSeparator.CurrentValue);

                    var refLowSeparator = alignmentViewModel.WavelengthSeparators.FirstOrDefault(x => x.CurrentValue >= selectedRefBand.XMin && x.CurrentValue <= selectedRefBand.XMax);

                    var refHighSeparator = alignmentViewModel.WavelengthSeparators.FirstOrDefault(x => x.CurrentValue > refLowSeparator.CurrentValue);

                    /* create the ref segment, depending on area selected by user */

                    var refSegment = alignedSpectrum.GetRefSegmentElements(refLowSeparator.CurrentValue,

                                                                           refHighSeparator.CurrentValue,

                                                                           getIsXMaxHighestBoundary(refHighSeparator.CurrentValue));

                    System.Diagnostics.Debug.WriteLine($"refsegment - xmin:{refSegment.FirstOrDefault().X}, xmax:{refSegment.LastOrDefault().X}");

                    double refSegmentLeftMean = refSegment.GetSegmentLeftMeanValue(spectrumAlignmentConfig.NumOfPointsForAlignment);

                    double refSegmentRightMean = refSegment.GetSegmentRightMeanValue(spectrumAlignmentConfig.NumOfPointsForAlignment);

                    double refSegmentLeftMean = refSegment.GetSegmentLeftMeanValue(alignmentViewModel.NumOfPointsForAlignment);

                    double refSegmentRightMean = refSegment.GetSegmentRightMeanValue(alignmentViewModel.NumOfPointsForAlignment);

                    /* retrieve segments on the left of selected one for later alignment */

                    alignLeftSide(ref alignedSpectrum,

                                   WavelengthModel refLowSeparator,

                                   double refSegmentLeftMean)

        {

            var leftSeparators = spectrumAlignmentConfig.WavelengthSeparators

            var leftSeparators = alignmentViewModel.WavelengthSeparators

                                                               .Where(x => x.MinValue < refLowSeparator.MinValue)

                                                               .OrderByDescending(x => x.MinValue);

            {

                var elements = aligningSpectrum

                                .GetLeftSegmentElements(leftSeparator.CurrentValue, getIsXMinLowestBoundary(leftSeparator.CurrentValue), rightSeparatorCurrentValue, getIsXMaxHighestBoundary(rightSeparatorCurrentValue))

                                .FixLeftSegment(refLeftValue, spectrumAlignmentConfig.NumOfPointsForAlignment);

                                .FixLeftSegment(refLeftValue, alignmentViewModel.NumOfPointsForAlignment);

                rightSeparatorCurrentValue = leftSeparator.CurrentValue;

                refLeftValue = elements.GetSegmentLeftMeanValue(spectrumAlignmentConfig.NumOfPointsForAlignment);

                refLeftValue = elements.GetSegmentLeftMeanValue(alignmentViewModel.NumOfPointsForAlignment);

            }

        }

                                    WavelengthModel refHighSeparator,

                                    double refSegmentRightMean)

        {

            var rightSeparators = spectrumAlignmentConfig.WavelengthSeparators

            var rightSeparators = alignmentViewModel.WavelengthSeparators

                                                            .Where(x => x.MinValue > refHighSeparator.MinValue);

            double leftSeparatorCurrentValue = refHighSeparator.CurrentValue;

            {

                var elements = aligningSpectrum

                                .GetRightSegmentElements(leftSeparatorCurrentValue, getIsXMinLowestBoundary(leftSeparatorCurrentValue), rightSeparator.CurrentValue, getIsXMaxHighestBoundary(rightSeparator.CurrentValue))

                                .FixRightSegment(refRightValue, spectrumAlignmentConfig.NumOfPointsForAlignment);

                                .FixRightSegment(refRightValue, alignmentViewModel.NumOfPointsForAlignment);

                leftSeparatorCurrentValue = rightSeparator.CurrentValue;

                refRightValue = elements.GetSegmentRightMeanValue(spectrumAlignmentConfig.NumOfPointsForAlignment);

                refRightValue = elements.GetSegmentRightMeanValue(alignmentViewModel.NumOfPointsForAlignment);

            }

        }

        private bool getIsXMinLowestBoundary(double currentValue)

        {

            return currentValue == spectrumAlignmentConfig.WavelengthSeparators.FirstOrDefault().CurrentValue;

            return currentValue == alignmentViewModel.WavelengthSeparators.FirstOrDefault().CurrentValue;

        }

        private bool getIsXMaxHighestBoundary(double currentValue)

        {

            return currentValue == spectrumAlignmentConfig.WavelengthSeparators.LastOrDefault().CurrentValue;

            return currentValue == alignmentViewModel.WavelengthSeparators.LastOrDefault().CurrentValue;

        }

        private void multiplyByRef(ref SpectrumModel aligningSpectrum,

using INAF.Apps.Uwp.SLabDataManager.Charts;

using INAF.Apps.Uwp.SLabDataManager.ViewModels.UserControlViewModels;

using INAF.Libraries.NetStandard.Extensions;

using INAF.Libraries.NetStandard.ScienceModels.Spectra;

using INAF.Libraries.Uwp.Logging;

using INAF.Libraries.Uwp.Xml;

using System.Threading.Tasks;

using Windows.Data.Xml.Dom;

using Windows.Storage;

using INAF.Libraries.NetStandard.Extensions;

namespace INAF.Apps.Uwp.SLabDataManager.Helpers.XmlReaders

{

    public sealed class ConfigReader : XmlReader

    {

        private readonly SpectrumAlignmentConfigModel alignmentConfig;

        private readonly AlignmentViewModel alignmentViewModel;

        public ConfigReader(IServiceProvider serviceProvider,

                            SpectrumAlignmentConfigModel alignmentConfigModel,

                            AlignmentViewModel alignmentViewModel,

                            XmlHelper xmlHelper,

                            Logger logger) : base(serviceProvider, xmlHelper, logger)

        {

            this.alignmentConfig = alignmentConfigModel;

            this.alignmentViewModel = alignmentViewModel;

        }

        public override async Task readFileAsync()

                    string _measureUnit = getNodeContent(node, "measureUnit");

                    int measureUnit = _measureUnit.ToIntInvariant();

                    if (!alignmentConfig.contains(index))

                        alignmentConfig.addSeparatorWavelength(new WavelengthModel(index, currentValue, semiRange, step, measureUnit, "WavelengthLabel".GetText()));

                    if (!alignmentViewModel.contains(index))

                        alignmentViewModel.addSeparatorWavelength(new WavelengthModel(index, currentValue, semiRange, step, measureUnit, "WavelengthLabel".GetText()));

                    index++;

                }

                alignmentConfig.orderSeparators();

                alignmentViewModel.orderSeparators();

            }

            catch (Exception ex)

            {