TeamAAS-VP-HeShuo/TeamAAS-VM/ViewModels/Product/CameraParamsViewModel.cs

using Prism.Commands;
using Prism.Events;
using Prism.Ioc;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using TeamAAS_VP.Controls;
using TeamAAS_VP.Data;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Events;
using TeamAAS_VP.Core;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using static NPOI.HSSF.Util.HSSFColor;
using Team.FFFeederService.Interfaces;
using TeamAAS_VP;
using Cognex.VisionPro;
using TeamAAS_VP.Resources.Languages;

namespace TeamAAS_VP.ViewModels.Product
{
    public class CameraParamsViewModel : BindableBase
    {
        IRegionManager _regionManager;
        IEventAggregator _eventAggregator;
        IContainerProvider _container;
        IDialogService _dialogService;
        ProductsViewModel productsViewModel;
        #region 属性

        private ProductModel _SelectProduct;

        /// <summary>
        /// 选中的产品
        /// </summary>
        public ProductModel SelectProduct
        {
            get { return _SelectProduct; }
            set { SetProperty(ref _SelectProduct, value); }
        }

        private ProcedureModel _SelectProcedure;

        /// <summary>
        /// 选中的流程
        /// </summary>
        public ProcedureModel SelectProcedure
        {
            get { return _SelectProcedure; }
            set { SetProperty(ref _SelectProcedure, value); }
        }

        private Management _management;

        public Management management
        {
            get { return _management; }
            set { SetProperty(ref _management, value); }
        }

        private bool _IsHaveFeeder=false;

        public bool IsHaveFeeder
        {
            get { return _IsHaveFeeder; }
            set { SetProperty(ref _IsHaveFeeder, value); }
        }

        private bool _IsHaveRobot = false;

        public bool IsHaveRobot
        {
            get { return _IsHaveRobot; }
            set { SetProperty(ref _IsHaveRobot, value); }
        }

        private IRobot _Robot;

        public IRobot Robot
        {
            get { return _Robot; }
            set { SetProperty(ref _Robot, value); }
        }

        private ICamera _Camera;

        public ICamera Camera
        {
            get { return _Camera; }
            set { SetProperty(ref _Camera, value); }
        }

        public IVoiceCoilMotorFeeder Feeder { get; set; }

        private ICogImage _Image;

        public ICogImage Image
        {
            get { return _Image; }
            set { SetProperty(ref _Image, value); }
        }

        private string _Message;
        public string Message
        {
            get { return _Message; }
            set { SetProperty(ref _Message, value); }
        }

        private float _ExposureTime;
        /// <summary>
        /// 相机曝光时间
        /// </summary>
        public float ExposureTime
        {
            get { return _ExposureTime; }
            set { SetProperty(ref _ExposureTime, value);
                SelectProcedure.ExposureTime = value;
                if (Camera != null)
                {
                    try
                    {
                        Camera.SetExposureTime(value);
                    }
                    catch (Exception)
                    {

                    }
                }
            }
        }

        private float _Gain;
        /// <summary>
        /// 相机增益
        /// </summary>
        public float Gain
        {
            get { return _Gain; }
            set { SetProperty(ref _Gain, value);
                SelectProcedure.Gain=value;
                if (Camera != null)
                {
                    try
                    {
                        Camera.SetGain(value);
                    }
                    catch (Exception)
                    {

                    }
                }
            }
        }

        private bool _IsGrap=true;
        public bool IsGrap
        {
            get { return _IsGrap; }
            set { SetProperty(ref _IsGrap, value); }
        }
        #endregion

        #region 命令
        private DelegateCommand _NextCommand;
        public DelegateCommand NextCommand =>
            _NextCommand ?? (_NextCommand = new DelegateCommand(ExecuteNextCommand));

        private DelegateCommand _BackCommand;
        public DelegateCommand BackCommand =>
            _BackCommand ?? (_BackCommand = new DelegateCommand(ExecuteBackCommand));

        private DelegateCommand _LoadedCommand;
        public DelegateCommand LoadedCommand =>
            _LoadedCommand ?? (_LoadedCommand = new DelegateCommand(ExecuteLoadedCommand));

        private DelegateCommand<double?> _LightValueChangedCommand;
        public DelegateCommand<double?> LightValueChangedCommand =>
            _LightValueChangedCommand ?? (_LightValueChangedCommand = new DelegateCommand<double?>(ExecuteLightValueChangedCommand));

        private DelegateCommand _StartGrabbingCommand;
        public DelegateCommand StartGrabbingCommand =>
            _StartGrabbingCommand ?? (_StartGrabbingCommand = new DelegateCommand(ExecuteStartGrabbingCommand).ObservesProperty(() => IsGrap));

        private DelegateCommand _StopGrabbingCommand;
        public DelegateCommand StopGrabbingCommand =>
            _StopGrabbingCommand ?? (_StopGrabbingCommand = new DelegateCommand(ExecuteStopGrabbingCommand).ObservesProperty(() => IsGrap));

        private DelegateCommand _LightValueAddCommand;
        public DelegateCommand LightValueAddCommand =>
            _LightValueAddCommand ?? (_LightValueAddCommand = new DelegateCommand(ExecuteLightValueAddCommand));

        private DelegateCommand _LightValueSubCommand;
        public DelegateCommand LightValueSubCommand =>
            _LightValueSubCommand ?? (_LightValueSubCommand = new DelegateCommand(ExecuteLightValueSubCommand));

        #endregion

        #region 事件

        #endregion

        public CameraParamsViewModel(IRegionManager regionManager, IEventAggregator ea, IContainerProvider container, IDialogService dialogService)
        {
            _regionManager = regionManager;
            _eventAggregator = ea;
            _container = container;
            _dialogService = dialogService;
            //订阅权限登录事件
            _eventAggregator.GetEvent<UserLoginNotification>().Subscribe(LoginChange);

            productsViewModel = _container.Resolve<ProductsViewModel>();
            SelectProduct = productsViewModel.SelectProduct;
            management= _container.Resolve<Management>();
            SelectProcedure = _container.Resolve<ProcessBasicsViewModel>().SelectProcedure;
        }

        #region 方法

        /// <summary>
        /// 下一步
        /// </summary>
        void ExecuteNextCommand()
        {
            SelectProcedure.ExposureTime = ExposureTime;
            SelectProcedure.Gain = Gain;
            if (Camera != null)
            {
                Camera.StopGrabbing();
                Camera.ImageCallbackEvent -= Camera_ImageCallbackEvent;
            }

            if (SelectProcedure.VisionModel == Enums.VisionModel.Simple)
            {
                _regionManager.RequestNavigate("ProductRegionContext", "SimpleProcedure");
            }
            else
            {
                _regionManager.RequestNavigate("ProductRegionContext", "AdvancedProcedure");
            }
        }

        /// <summary>
        /// 上一步
        /// </summary>
        void ExecuteBackCommand()
        {
            if (Camera != null)
            {
                Camera.StopGrabbing();
                Camera.ImageCallbackEvent -= Camera_ImageCallbackEvent;
            } 
            
            _regionManager.RequestNavigate("ProductRegionContext", "ProcessBasics");
        }

        async void ExecuteLoadedCommand()
        {
            if (_container.Resolve<Management>().CurrentUser.userPart == Enums.UserPart.Operator)
            {
                IsAllowEdit = false;
            }
            else
            {
                IsAllowEdit = true;
            }
            try
            {
                productsViewModel = _container.Resolve<ProductsViewModel>();
                SelectProduct = productsViewModel.SelectProduct;
                management = _container.Resolve<Management>();
                SelectProcedure = _container.Resolve<ProcessBasicsViewModel>().SelectProcedure;

                if (SelectProcedure.RobotId != Guid.Empty)
                {
                    IsHaveRobot = true;
                    Robot = _container.Resolve<Management>().RobotService.GetRobot(SelectProcedure.RobotId);
                }
                else
                {
                    IsHaveRobot = false;
                }
                if (SelectProcedure.FeederId != Guid.Empty)
                {
                    IsHaveFeeder = true;
                    Feeder = _container.Resolve<Management>().FeederService.GetFeeder(SelectProcedure.FeederId);
                    if (Feeder.IsConnected)
                    {
                        await Feeder.OpenLightAsync();
                        await Feeder.SetLightValueAsync((ushort)SelectProcedure.LightValue);
                    }
                }
                else
                {
                    IsHaveFeeder = false;
                }

                Camera = _container.Resolve<Management>().CameraService.GetCamera(SelectProcedure.CameraId);

                if (SelectProcedure.ExposureTime==0)
                {
                    SelectProcedure.ExposureTime = 5000;
                }
                ExposureTime = SelectProcedure.ExposureTime;
                Gain= SelectProcedure.Gain;
                
                if (Camera!=null)
                {
                    Camera.SetExposureTime(ExposureTime);
                    Camera.SetGain(Gain);
                    Camera.ImageCallbackEvent += Camera_ImageCallbackEvent;
                    //Camera.Grab();
                }
                
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("相机实时图像参数界面加载时出错！", ex);
                MessageBox.Show(ex.Message);
            }
        }

        private void Camera_ImageCallbackEvent(ICogImage image,TimeSpan totaltime,string errormessage)
        {
            Image = image;
            App.Current.Dispatcher.Invoke(new
                 Action(() =>
                 {
                     if (errormessage != null && !string.IsNullOrEmpty(errormessage))
                     {
                         Message = $"{Lang.耗时}:{totaltime.TotalMilliseconds.ToString("F1")} ms Error:{errormessage}";
                     }
                     else 
                     {
                         Message = $"{Lang.耗时}:{totaltime.TotalMilliseconds.ToString("F1")} ms";
                     }
                 }));
        }

        /// <summary>
        /// 光源亮度调整时
        /// </summary>
        async void ExecuteLightValueChangedCommand(double? lightvalue)
        {
            try
            {
                if (lightvalue == null) return;
                if (Feeder == null || !Feeder.IsConnected) return;
                await Feeder.SetLightValueAsync((ushort)lightvalue);
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("产品实时图像界面-Feeder光源亮度更改时出错！", ex);
            }
        }

        void ExecuteLightValueSubCommand()
        {
            SelectProcedure.LightValue--;
        }

        void ExecuteLightValueAddCommand()
        {
            SelectProcedure.LightValue++;
        }

        /// <summary>
        /// 停止采集
        /// </summary>
        void ExecuteStopGrabbingCommand()
        {
            IsGrap = false;
            if (Camera != null)
                Camera.StopGrabbing();
            IsGrap = true;
        }
        /// <summary>
        /// 开始采集
        /// </summary>
        void ExecuteStartGrabbingCommand()
        {
            IsGrap = false;
            if (Camera != null)
                Camera.StartGrabbing();
            IsGrap = true;
        }
        #endregion

        private bool _IsAllowEdit = false;

        public bool IsAllowEdit
        {
            get { return _IsAllowEdit; }
            set { SetProperty(ref _IsAllowEdit, value); }
        }

        private void LoginChange(Models.User user)
        {
            if (user.userPart == Enums.UserPart.Operator)
            {
                IsAllowEdit = false;
            }
            else
            {
                IsAllowEdit = true;
            }
        }
    }
}