Example #1
0
        /// <summary>
        /// Sets up the reactive bindings for all Ocr controls.
        /// </summary>
        /// <param name="manager">The ViewROIManager instance to use.</param>
        private void BindOcrControls(ViewROIManager manager)
        {
            // Bind image aspect for acquired images.
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.OcrVM.ImageHeight)
                                       .Subscribe(x => manager.ImageHeight = x));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.OcrVM.ImageWidth)
                                       .Subscribe(x => manager.ImageWidth = x));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.OcrVM.Display)
                                       .Where(x => x.DisplayList.Count > 0)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => manager.ShowDisplayCollection(x)));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.OcrVM.DebugDisplay)
                                       .Where(x => x.DisplayList.Count > 0)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => manager.ShowDisplayCollection(x)));
        }
        /// <summary>
        /// Sets up the reactive bindings for all Acquire Acquisition controls.
        /// </summary>
        /// <param name="manager">The manager.</param>
        private void BindAcquireAcquisitionControls(ViewROIManager manager)
        {
            // buttonLiveVideo
            this.BindCommand(this.MainViewModel, vm => vm.AcquireAcquisitionVM.LiveVideoCommand, x => x.acquisitionAcquirePage.buttonLiveVideo);
            this.BindCommand(this.MainViewModel, vm => vm.AcquireAcquisitionVM.SelectFileCommand, x => x.acquisitionAcquirePage.buttonSelectFile);
            this.BindCommand(this.MainViewModel, vm => vm.AcquireAcquisitionVM.SaveImageCommand, x => x.acquisitionAcquirePage.buttonSave);

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.LiveVideoMode)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x =>
            {
                if (x)
                {
                    this.acquisitionAcquirePage.buttonLiveVideo.Content = "Stop Live Video";
                }
                else
                {
                    this.acquisitionAcquirePage.buttonLiveVideo.Content = "Start Live Video";
                }
            }));

            // buttonInitializeCamera
            this.BindCommand(this.MainViewModel, vm => vm.AcquireAcquisitionVM.InitializeCommand, x => x.acquisitionAcquirePage.buttonInitializeCamera);

            // buttonAcquire
            this.BindCommand(this.MainViewModel, vm => vm.AcquireAcquisitionVM.Command, x => x.acquisitionAcquirePage.buttonAcquire);

            // Bind the buttonSelectFile visibility to SelectFileVisibility property.
            this.OneWayBind(this.MainViewModel, vm => vm.AcquireAcquisitionVM.SelectFileVisibility, y => y.acquisitionAcquirePage.buttonSelectFile.Visibility);

            // Bind image aspect for acquired images.
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.AcquiredImageHeight)
                                       .Subscribe(x => manager.ImageHeight = x));
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.AcquiredImageWidth)
                                       .Subscribe(x => manager.ImageWidth = x));

            // Display collection.
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.Display)
                                       .Where(x => x.DisplayList.Count > 0)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x =>
            {
                try
                {
                    manager.ShowDisplayCollection(x);
                }
                finally
                {
                    this.MainViewModel.AcquireAcquisitionVM.IsProcessing = false;
                }
            }));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.DebugDisplay)
                                       .Where(x => x.DisplayList.Count > 0)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => manager.ShowDisplayCollection(x)));

            // comboBoxAcquisitionInterfaceName
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.AcquisitionInterfaces)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxAcquisitionInterfaceName.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.AcquisitionInterfaces.ToList()));
            this.acquisitionAcquirePage.comboBoxAcquisitionInterfaceName.SelectedIndex = 1;

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxAcquisitionInterfaceName.SelectedItem)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.CurrentAcquisitionInterfaceName));

            // comboBoxHorizontalResolution
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.HorizontalResolutionParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxHorizontalResolution.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.HorizontalResolutionParameters.ToIArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxHorizontalResolution.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.HorizontalResolution));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxHorizontalResolution.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, @"^-?\d+$") == true)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.HorizontalResolution));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.HorizontalResolution)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxHorizontalResolution.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxHorizontalResolution.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.HorizontalResolution)));

            // comboBoxVerticalResolution
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.VerticalResolutionParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxVerticalResolution.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.VerticalResolutionParameters.ToIArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxVerticalResolution.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.VerticalResolution));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxVerticalResolution.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, @"^-?\d+$") == true)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.VerticalResolution));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.VerticalResolution)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxVerticalResolution.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxVerticalResolution.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.VerticalResolution)));

            // comboBoxImageWidth
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.ImageWidthParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxImageWidth.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.ImageWidthParameters.ToIArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxImageWidth.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.ImageWidth));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxImageWidth.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, @"^-?\d+$") == true)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.ImageWidth));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.ImageWidth)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxImageWidth.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxImageWidth.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.ImageWidth)));

            // comboBoxImageHeight
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.ImageHeightParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxImageHeight.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.ImageHeightParameters.ToIArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxImageHeight.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.ImageHeight));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxImageHeight.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, @"^-?\d+$") == true)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.ImageHeight));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.ImageHeight)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxImageHeight.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxImageHeight.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.ImageHeight)));

            // comboBoxStartRow
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.StartRowParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxStartRow.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.StartRowParameters.ToIArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxStartRow.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.StartRow));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxStartRow.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, @"^-?\d+$") == true)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.StartRow));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.StartRow)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxStartRow.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxStartRow.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.StartRow)));

            // comboBoxStartColumn
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.StartColumnParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxStartColumn.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.StartColumnParameters.ToIArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxStartColumn.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.StartColumn));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxStartColumn.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, @"^-?\d+$") == true)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.StartColumn));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.StartColumn)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxStartColumn.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxStartColumn.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.StartColumn)));

            // comboBoxField
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.FieldParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxField.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.FieldParameters.ToSArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxField.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.Field));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxField.Text)
                                       .Where(x => x != string.Empty)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.Field));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.Field)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxField.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxField.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.Field)));

            // comboBitsPerChannel
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.BitsPerChannelParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBitsPerChannel.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.BitsPerChannelParameters.ToIArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBitsPerChannel.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.BitsPerChannel));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBitsPerChannel.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, @"^-?\d+$") == true)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.BitsPerChannel));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.BitsPerChannel)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBitsPerChannel.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBitsPerChannel.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.BitsPerChannel)));

            // comboBoxColorSpace
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.ColorSpaceParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxColorSpace.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.ColorSpaceParameters.ToSArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxColorSpace.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.ColorSpace));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxColorSpace.Text)
                                       .Where(x => x != string.Empty)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.ColorSpace));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.ColorSpace)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxColorSpace.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxColorSpace.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.ColorSpace)));

            // comboBoxGeneric
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.GenericParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxGeneric.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.GenericParameters.ToSArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxGeneric.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.Generic));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxGeneric.Text)
                                       .Where(x => x != string.Empty)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.Generic));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.Generic)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxGeneric.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxGeneric.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.Generic)));

            // comboBoxExternalTrigger
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.ExternalTriggerParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxExternalTrigger.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.ExternalTriggerParameters.ToSArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxExternalTrigger.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.ExternalTrigger));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxExternalTrigger.Text)
                                       .Where(x => x != string.Empty)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.ExternalTrigger));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.ExternalTrigger)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxExternalTrigger.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxExternalTrigger.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.ExternalTrigger)));

            // comboBoxCameraType
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.CameraTypeParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxCameraType.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.CameraTypeParameters.ToSArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxCameraType.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.CameraType));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxCameraType.Text)
                                       .Where(x => x != string.Empty)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.CameraType));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.CameraType)
                                       .Where(_ => this.MainViewModel.AcquireAcquisitionVM.CurrentAcquisitionInterfaceName != "File")
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxCameraType.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxCameraType.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.CameraType)));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.CameraType)
                                       .Where(_ => this.MainViewModel.AcquireAcquisitionVM.CurrentAcquisitionInterfaceName == "File")
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxCameraType.Text = MainViewModel.AcquireAcquisitionVM.CameraType));

            // comboBoxDevice
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.DeviceParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxDevice.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.DeviceParameters.ToSArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxDevice.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.Device));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxDevice.Text)
                                       .Where(x => x != string.Empty)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.Device));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.Device)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxDevice.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxDevice.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.Device)));

            // comboBoxPort
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.PortParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxPort.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.PortParameters.ToIArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxPort.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.Port));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxPort.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, @"^-?\d+$") == true)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.Port));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.Port)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxPort.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxPort.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.Port)));

            // comboBoxLineIn
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.LineInParameters)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxLineIn.ItemsSource = this.MainViewModel.AcquireAcquisitionVM.LineInParameters.ToIArr()));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxLineIn.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.LineIn));

            this.disposeCollection.Add(this.acquisitionAcquirePage.WhenAnyValue(x => x.comboBoxLineIn.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, @"^-?\d+$") == true)
                                       .BindTo(this.MainViewModel.AcquireAcquisitionVM, vm => vm.LineIn));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireAcquisitionVM.LineIn)
                                       .Subscribe(_ => this.acquisitionAcquirePage.comboBoxLineIn.SelectedIndex =
                                                      this.acquisitionAcquirePage.comboBoxLineIn.Items.IndexOf(MainViewModel.AcquireAcquisitionVM.LineIn)));
        }
        /// <summary>
        /// Sets up the reactive bindings for all Acquire camera calibration controls.
        /// </summary>
        /// <param name="manager">The manager.</param>
        private void BindAcquireCalibrationControls(ViewROIManager manager)
        {
            string RegexFloat   = @"^-?\d+\.?\d*$";
            string RegexInteger = @"^-?\d+$";

            this.BindCommand(this.MainViewModel, vm => vm.AcquireCalibrationVM.SetParametersCommand, x => x.calibrationAcquirePage.ButtonSetInitialParameters);
            this.BindCommand(this.MainViewModel, vm => vm.AcquireCalibrationVM.AcquireCalibrationImagesCommand, x => x.calibrationAcquirePage.ButtonAcquireCalibrationImages);
            this.BindCommand(this.MainViewModel, vm => vm.AcquireCalibrationVM.CalibrateCommand, x => x.calibrationAcquirePage.ButtonCalibrate);
            this.BindCommand(this.MainViewModel, vm => vm.AcquireCalibrationVM.RectifyImageCommand, x => x.calibrationAcquirePage.ButtonRectifyTestImage);
            this.BindCommand(this.MainViewModel, vm => vm.AcquireCalibrationVM.LoadCalibrationMapCommand, x => x.calibrationAcquirePage.ButtonLoadCalibrationMap);
            this.BindCommand(this.MainViewModel, vm => vm.AcquireCalibrationVM.LoadTestCalibrationImageCommand, x => x.calibrationAcquirePage.ButtonLoadTestCalibrationImage);
            this.BindCommand(this.MainViewModel, vm => vm.AcquireCalibrationVM.SaveRectifiedImageCommand, x => x.calibrationAcquirePage.ButtonSaveRectifiedTestImage);
            this.BindCommand(this.MainViewModel, vm => vm.AcquireCalibrationVM.LoadCalibImagesFromFileCommand, x => x.calibrationAcquirePage.ButtonLoadCalibrationImages);
            this.BindCommand(this.MainViewModel, vm => vm.AcquireCalibrationVM.SaveCalibrationMapCommand, x => x.calibrationAcquirePage.ButtonSaveCalibrationMap);

            // ButtonLoadCalibrationImages enabled bound to LoadCalibImagesFromFileCanExecute observable.
            this.disposeCollection.Add(this.WhenAnyObservable(x => x.MainViewModel.AcquireCalibrationVM.LoadCalibImagesFromFileCanExecute)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => this.calibrationAcquirePage.ButtonLoadCalibrationImages.IsEnabled = x));

            // ButtonAcquireCalibrationImages enabled bound to LoadCalibImagesFromFileCanExecute observable.
            this.disposeCollection.Add(this.WhenAnyObservable(x => x.MainViewModel.AcquireCalibrationVM.LoadCalibImagesFromFileCanExecute)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => this.calibrationAcquirePage.ButtonAcquireCalibrationImages.IsEnabled = x));

            // ButtonResetCalibrationImages enabled bound to LoadCalibImagesFromFileCanExecute observable.
            this.disposeCollection.Add(this.WhenAnyObservable(x => x.MainViewModel.AcquireCalibrationVM.LoadCalibImagesFromFileCanExecute)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => this.calibrationAcquirePage.ButtonResetCalibrationImages.IsEnabled = x));

            // ButtonSaveCalibrationMap enabled bound to SaveCalibrationCanExecute observable.
            this.disposeCollection.Add(this.WhenAnyObservable(x => x.MainViewModel.AcquireCalibrationVM.SaveCalibrationMapCanExecute)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => this.calibrationAcquirePage.ButtonSaveCalibrationMap.IsEnabled = x));

            // ButtonLoadTestCalibrationImage enabled bound to LoadTestImageCanExecute observable.
            this.disposeCollection.Add(this.WhenAnyObservable(x => x.MainViewModel.AcquireCalibrationVM.LoadTestCalibrationImageCanExecute)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => this.calibrationAcquirePage.ButtonLoadTestCalibrationImage.IsEnabled = x));

            // ButtonSaveRectifiedTestImage enabled bound to SaveRectifyImageCanExecute observable.
            this.disposeCollection.Add(this.WhenAnyObservable(x => x.MainViewModel.AcquireCalibrationVM.SaveRectifiedImageCanExecute)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x =>
            {
                this.calibrationAcquirePage.ButtonSaveRectifiedTestImage.IsEnabled = x;
            }));

            // CheckBoxCorrectImages enabled bound to LoadTestImageCanExecute observable.
            this.disposeCollection.Add(this.WhenAnyObservable(x => x.MainViewModel.AcquireCalibrationVM.LoadTestCalibrationImageCanExecute)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => this.calibrationAcquirePage.CheckBoxCorrectImages.IsEnabled = x));

            this.Bind(this.MainViewModel, vm => vm.AcquireCalibrationVM.CorrectNewImages, x => x.calibrationAcquirePage.CheckBoxCorrectImages.IsChecked);

            // Set cursor to wait while calibration processes are busy.  Does not affect HalconWindow. ??
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.IsBusy)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x =>
            {
                if (x)
                {
                    System.Windows.Input.Mouse.OverrideCursor = System.Windows.Input.Cursors.Wait;
                }
                else
                {
                    System.Windows.Input.Mouse.OverrideCursor = null;
                }
            }));

            // ComboBoxFocalLength
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.FocalLengthParameters)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxFocalLength.ItemsSource = this.MainViewModel.AcquireCalibrationVM.FocalLengthParameters.ToDArr()));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxFocalLength.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.FocalLength));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxFocalLength.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, RegexFloat) == true)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.FocalLength));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.FocalLength)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxFocalLength.SelectedIndex =
                                                      this.calibrationAcquirePage.ComboBoxFocalLength.Items.IndexOf(MainViewModel.AcquireCalibrationVM.FocalLength)));

            // ComboBoxSensorSizeX
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.SensorSizeXParameters)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxSensorSizeX.ItemsSource = this.MainViewModel.AcquireCalibrationVM.SensorSizeXParameters.ToDArr()));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxSensorSizeX.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.SensorSizeX));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxSensorSizeX.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, RegexFloat) == true)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.SensorSizeX));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.SensorSizeX)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxSensorSizeX.SelectedIndex =
                                                      this.calibrationAcquirePage.ComboBoxSensorSizeX.Items.IndexOf(MainViewModel.AcquireCalibrationVM.SensorSizeX)));

            // ComboBoxSensorSizeY
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.SensorSizeYParameters)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxSensorSizeY.ItemsSource = this.MainViewModel.AcquireCalibrationVM.SensorSizeYParameters.ToDArr()));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxSensorSizeY.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.SensorSizeY));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxSensorSizeY.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, RegexFloat) == true)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.SensorSizeY));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.SensorSizeY)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxSensorSizeY.SelectedIndex =
                                                      this.calibrationAcquirePage.ComboBoxSensorSizeY.Items.IndexOf(MainViewModel.AcquireCalibrationVM.SensorSizeY)));

            // ComboBoxCalibrationImageWidth
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.ImageWidthParameters)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxCalibrationImageWidth.ItemsSource = this.MainViewModel.AcquireCalibrationVM.ImageWidthParameters.ToIArr()));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxCalibrationImageWidth.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.ImageWidth));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxCalibrationImageWidth.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, RegexInteger) == true)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.ImageWidth));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.ImageWidth)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxCalibrationImageWidth.SelectedIndex =
                                                      this.calibrationAcquirePage.ComboBoxCalibrationImageWidth.Items.IndexOf(MainViewModel.AcquireCalibrationVM.ImageWidth)));

            // ComboBoxCalibrationImageHeight
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.ImageHeightParameters)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxCalibrationImageHeight.ItemsSource = this.MainViewModel.AcquireCalibrationVM.ImageHeightParameters.ToIArr()));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxCalibrationImageHeight.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.ImageHeight));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxCalibrationImageHeight.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, RegexInteger) == true)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.ImageHeight));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.ImageHeight)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxCalibrationImageHeight.SelectedIndex =
                                                      this.calibrationAcquirePage.ComboBoxCalibrationImageHeight.Items.IndexOf(MainViewModel.AcquireCalibrationVM.ImageHeight)));

            // ComboBoxCalibrationCameraType
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.CameraTypeParameters)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxCalibrationCameraType.ItemsSource = this.MainViewModel.AcquireCalibrationVM.CameraTypeParameters.ToSArr()));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxCalibrationCameraType.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.CameraType));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxCalibrationCameraType.Text)
                                       .Where(x => x != string.Empty)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.CameraType));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.CameraType)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxCalibrationCameraType.SelectedIndex =
                                                      this.calibrationAcquirePage.ComboBoxCalibrationCameraType.Items.IndexOf(MainViewModel.AcquireCalibrationVM.CameraType)));

            // ComboBoxCalibrationPlateName
            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.HalconCalibrationPlateParameters)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxCalibrationPlateName.ItemsSource = this.MainViewModel.AcquireCalibrationVM.HalconCalibrationPlateParameters.ToSArr()));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxCalibrationPlateName.SelectedItem)
                                       .Where(x => x != null)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.HalconCalibrationPlateName));

            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.ComboBoxCalibrationPlateName.Text)
                                       .Where(x => x != string.Empty)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.HalconCalibrationPlateName));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.HalconCalibrationPlateName)
                                       .Subscribe(_ => this.calibrationAcquirePage.ComboBoxCalibrationPlateName.SelectedIndex =
                                                      this.calibrationAcquirePage.ComboBoxCalibrationPlateName.Items.IndexOf(MainViewModel.AcquireCalibrationVM.HalconCalibrationPlateName)));

            // TextBoxRectifiedImageWidth
            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.TextBoxRectifiedImageWidth.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, RegexInteger) == true)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.RectifiedImageWidth));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.RectifiedImageWidth)
                                       .Subscribe(x => this.calibrationAcquirePage.TextBoxRectifiedImageWidth.Text = this.MainViewModel.AcquireCalibrationVM.RectifiedImageWidth.ToString()));

            // TextBoxRectifiedImageHeight
            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.TextBoxRectifiedImageHeight.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, RegexInteger) == true)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.RectifiedImageHeight));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.RectifiedImageHeight)
                                       .Subscribe(x => this.calibrationAcquirePage.TextBoxRectifiedImageHeight.Text = this.MainViewModel.AcquireCalibrationVM.RectifiedImageHeight.ToString()));

            // TextBoxCalibratedScale
            this.disposeCollection.Add(this.calibrationAcquirePage.WhenAnyValue(x => x.TextBoxCalibratedScale.Text)
                                       .Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, RegexFloat) == true)
                                       .BindTo(this.MainViewModel.AcquireCalibrationVM, vm => vm.CalibratedScale));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.CalibratedScale)
                                       .Subscribe(x => this.calibrationAcquirePage.TextBoxCalibratedScale.Text = this.MainViewModel.AcquireCalibrationVM.CalibratedScale.ToString("0.0######")));

            // IntegerUpDownWorldPoseIndex
            this.Bind(this.MainViewModel, x => x.AcquireCalibrationVM.WorldPoseIndex, x => x.calibrationAcquirePage.IntegerUpDownWorldPoseIndex.Value);

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.Display)
                                       .Where(x => x.DisplayList.Count > 0)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => manager.ShowDisplayCollection(x)));

            this.disposeCollection.Add(this.WhenAnyValue(x => x.MainViewModel.AcquireCalibrationVM.DebugDisplay)
                                       .Where(x => x.DisplayList.Count > 0)
                                       .ObserveOn(RxApp.MainThreadScheduler)
                                       .Subscribe(x => manager.ShowDisplayCollection(x)));
        }