public IPhaseExtractor NewPhaseExtractor()
        {
            if (GeneralConfigurations.Get().ViewPhase)
            {
                return(new FourierOnlyPhaseExtractor());
            }
            var config    = CorrectorConfigurations.Get();
            var misConfig = MiscellaneousConfigurations.Get();

            switch (config.PhaseType)
            {
            case PhaseType.FullRange:
                return(new FourierOnlyPhaseExtractor());

            case PhaseType.CenterInterpolation:
                return(new CorrectCenterPhaseExtractor(NewApodizer(),
                                                       config.CenterSpanLength / 2));

            case PhaseType.SpecificRange:
                return(new SpecificRangePhaseExtractor((int)config.RangeStart, (int)config.RangeEnd,
                                                       misConfig.MinFlatPhasePtsNumCnt, misConfig.MaxPhaseStd));

            case PhaseType.OldCenterInterpolation:
                return(new ClassicWrongPhaseExtractor(NewApodizer(),
                                                      config.CenterSpanLength / 2));

            case PhaseType.SpecificFreqRange:
                return(new SpecificFreqRangePhaseExtractor(config.RangeStart, config.RangeEnd,
                                                           SamplingConfigurations.Get().SamplingRateInMHz, misConfig.MinFlatPhasePtsNumCnt,
                                                           misConfig.MaxPhaseStd));

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
 public IPhaseSynthesizer NewPhaseSynthesizer()
 {
     if (CorrectorConfigurations.Get().RealSpec)
     {
         return(new RealPhaseSynthesizer());
     }
     return(new ComplexPhaseSynthesizer());
 }
        public IAccumulator NewPulseSequenceProcessor()
        {
            var config = CorrectorConfigurations.Get();

            if (config.LockDip)
            {
                return(new LockDipAccumulator(NewCrestFinder(), NewSlicer(), NewPulsePreprocessor(), NewCorrector(), config.LockDipFreqInMHz,
                                              MiscellaneousConfigurations.Get().LockDipScanRadiusInMhz, SamplingConfigurations.Get().SamplingRateInMHz));
            }
            return(new Accumulator(NewCrestFinder(), NewSlicer(), NewPulsePreprocessor(), NewCorrector()));
        }
        public IWriterV2 <TracedSpectrum> NewSpectrumWriter()
        {
            var prefix = "[Sum]";

            if (CorrectorConfigurations.Get().LockDip)
            {
                prefix += "[LockOn-" + CorrectorConfigurations.Get().LockDipFreqInMHz.ToString("F2") + "MHz]";
            }
            return(new SpectrumWriterV2(GeneralConfigurations.Get().Directory, prefix,
                                        GeneralConfigurations.Get().SaveType));
        }
        private ICorrectorV2 NewCorrectorNoFlip()
        {
            switch (CorrectorConfigurations.Get().CorrectorType)
            {
            case CorrectorType.Mertz:
                return(new MertzCorrectorV2(NewPhaseExtractor(), NewApodizer(), NewPhaseSynthesizer()));

            case CorrectorType.Fake:
                return(new FakeCorrectorV2(NewApodizer()));

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
        private IApodizer NewApodizer()
        {
            switch (CorrectorConfigurations.Get().ApodizerType)
            {
            case ApodizerType.Fake:
                return(new FakeApodizer());

            case ApodizerType.Triangular:
                return(new TriangulerApodizer());

            case ApodizerType.Hann:
                return(new HannApodizer());

            case ApodizerType.Hamming:
                return(new HammingApodizer());

            case ApodizerType.Cosine:
                return(new CosineApodizer());

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
 public IPulsePreprocessor NewPulsePreprocessor()
 {
     return(new BalancePulsePreprocessor(CorrectorConfigurations.Get().ZeroFillFactor));
 }
        public MainWindow()
        {
            // init system components
            InitializeComponent();

            _possibleWrongLabels = new[] { LbPeakMinAmp, LbRangeStart, LbRangeEnd, LbRepRate };
            _originalThickness   = _possibleWrongLabels[0].BorderThickness;
            _originalBrush       = _possibleWrongLabels[0].BorderBrush;

            if (File.Exists(@"default.svcfg"))
            {
                ConfigsHolder.Load(@"default.svcfg");
            }
            else
            {
                // init configurations
                SamplingConfigurations.Initialize(
                    deviceName: "Dev3",
                    channel: 0,
                    samplingRateInMHz: 100,
                    recordLengthInM: 1,
                    range: 10);

                GeneralConfigurations.Initialize(
                    repetitionRate: 400,
                    threadNum: 4,
                    dispPoints: 1000,
                    directory: @"C:\buffer\captured\",
                    viewPhase: false,
                    saveType: SaveType.Magnitude,
                    queueSize: 48,
                    saveSample: false,
                    saveSpec: false,
                    saveAcc: false,
                    operationMode: OperationMode.Manual,
                    targetCnt: 100);

                SliceConfigurations.Initialize(
                    crestAmplitudeThreshold: 0.5,
                    peakMinLength: 2000,
                    crestAtCenter: true,
                    rulerType: RulerType.MinLength,
                    findAbs: true,
                    autoAdjust: true,
                    fixedLength: 232171,
                    reference: false
                    );

                CorrectorConfigurations.Initialize(
                    zeroFillFactor: 1,
                    centerSpanLength: 512,
                    correctorType: CorrectorType.Mertz,
                    apodizerType: ApodizerType.Hann,
                    phaseType: PhaseType.FullRange,
                    realPhase: false,
                    rangeStart: 3,
                    rangeEnd: 4,
                    lockDip: false,
                    lockDipFreqInMHz: 5
                    );

                MiscellaneousConfigurations.Initialize(
                    waitEmptyProducerMsTimeout: 5000,
                    minFlatPhasePtsNumCnt: 200,
                    maxPhaseStd: 0.34,
                    pythonPath: @"C:\Anaconda3\python.exe",
                    lockDipScanRadiusInMHz: 0.4,
                    autoFlip: false);
            }


            SliceConfigs     = SliceConfigurations.Get();
            CorrectorConfigs = CorrectorConfigurations.Get();
            SampleConfigs    = SamplingConfigurations.Get();
            GeneralConfigs   = GeneralConfigurations.Get();

            CbPhaseType.SelectionChanged += (sender, args) => {
                HideAllPhaseOptions();

                var selected = (PhaseType)args.AddedItems[0];
                HandleAdditionalPhaseOptions(selected);
            };

            CbSliceLength.SelectionChanged += (sender, args) => {
                var selected = (RulerType)args.AddedItems[0];
                TbFixedLength.Visibility = selected == RulerType.FixLength ? Visibility.Visible : Visibility.Hidden;
            };

            CbCorrector.SelectionChanged += (sender, args) => {
                var selected = (CorrectorType)args.AddedItems[0];
                switch (selected)
                {
                case CorrectorType.Fake:
                    Hide(CbPhaseType);
                    Hide(LbPhaseType);
                    HideAllPhaseOptions();
                    break;

                case CorrectorType.Mertz:
                    Show(CbPhaseType);
                    Show(LbPhaseType);
                    HandleAdditionalPhaseOptions((PhaseType?)CbPhaseType.SelectedItem ?? PhaseType.FullRange);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            };
            CbOperationMode.SelectionChanged += (sender, args) => {
                var selected = (OperationMode)args.AddedItems[0];
                switch (selected)
                {
                case OperationMode.Manual:
                    Hide(TbTargetCnt);
                    break;

                case OperationMode.Single:
                case OperationMode.Loop:
                    Show(TbTargetCnt);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            };
            RoutedEventHandler ckPhaseOnChecked = (sender, args) => {
                var correct = !CkPhase.IsChecked.GetValueOrDefault(false);
                if (correct)
                {
                    Show(LbCorrector);
                    Show(CbCorrector);
                    Show(CbApodizationType);
                    Show(LbApodize);
                    Show(CkLockDip);
                    Show(TbLockDip);
                    Show(LbLockDip);
                    Show(CkSpecReal);
                    if ((CorrectorType)CbCorrector.SelectedItem != CorrectorType.Fake)
                    {
                        Show(CbPhaseType);
                        Show(LbPhaseType);
                        HandleAdditionalPhaseOptions((PhaseType?)CbPhaseType.SelectedItem ?? PhaseType.FullRange);
                    }
                }
                else
                {
                    Hide(CbCorrector);
                    Hide(LbCorrector);
                    Hide(CbApodizationType);
                    Hide(LbApodize);
                    Hide(CkLockDip);
                    Hide(TbLockDip);
                    Hide(LbLockDip);
                    Hide(CkSpecReal);
                    Hide(CbPhaseType);
                    Hide(LbPhaseType);
                    HideAllPhaseOptions();
                }
            };

            CkPhase.Checked   += ckPhaseOnChecked;
            CkPhase.Unchecked += ckPhaseOnChecked;

            // bind configs to controls
            DataContext = this;

//            SamplingConfigurations.Get().Bind(TbDeviceName, TbChannel, TbSamplingRate, TbRecordLength, TbRange);
//            GeneralConfigurations.Get()
//                .Bind(TbRepRate, TbThreadNum, TbDispPoints, TbSavePath, CkPhase, CbSaveType, TbQueueSize,
//                    CkCaptureSample, CkCaptureSpec, CkCaptureAcc, CbOperationMode, TbTargetCnt);
//            SliceConfigurations.Get()
//                .Bind(TbPtsBeforeCrest, TbCrestMinAmp, CbSliceLength, CkAutoAdjust, CkFindAbs, TbFixedLength, CkRef);
//            CorrectorConfigurations.Get()
//                .Bind(TbZeroFillFactor, TbCenterSpanLength, CbCorrector, CbApodizationType, CbPhaseType, TbRangeStart,
//                    TbRangeEnd, CkAutoFlip, CkSpecReal);
            // init custom components

            SwitchButton          = new ToggleButtonV2(ToggleButton, false, "Stop", "Start");
            SwitchButton.TurnOn  += TurnOn;
            SwitchButton.TurnOff += ClearFromRunningState;
            SizeChanged          += (sender, args) => { Adapter?.OnWindowZoomed(); };
            // todo text disapeared

            CkCaptureSpec.Checked += (sender, args) => { CkCaptureAcc.IsChecked = true; };

            Closing += (sender, args) => { _statsWindow?.Close(); };

            LocationChanged += (sender, args) => {
                if (_statsWindow == null)
                {
                    return;
                }
                _statsWindow.Left = this.Left + this.Width - 15;
                _statsWindow.Top  = this.Top;
            };
        }