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

using MathNet.Numerics.LinearAlgebra;
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.Linq;
using System.Threading.Tasks;
using System.Windows;
using Team.FFFeederService;
using Team.FFFeederService.Interfaces;
using TeamAAS_VP.Events;
using TeamAAS_VP.Core;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.ViewModels.Calibration;
using TeamAAS_VP;
using Cognex.VisionPro.Blob;

namespace TeamAAS_VP.ViewModels.Product
{
    public class FeederBlobParamsViewModel : BindableBase, IDialogAware
    {
        IRegionManager _regionManager;
        IRegionNavigationService _regionNavigationService;
        IContainerProvider _container;
        IDialogService _dialogService;
        IEventAggregator _eventAggregator;

        #region 属性

        private CogBlobEditV2 _BlobEditV2;
        /// <summary>
        /// Blob工具
        /// </summary>
        public CogBlobEditV2 BlobEditV2
        {
            get { return _BlobEditV2; }
            set { SetProperty(ref _BlobEditV2, value); }
        }

        private double _MinArea;

        public double MinArea
        {
            get { return _MinArea; }
            set { SetProperty(ref _MinArea,value); }
        }

        private double _BlobTotalArea;

        public double BlobTotalArea
        {
            get { return _BlobTotalArea; }
            set { SetProperty(ref _BlobTotalArea,value); }
        }


        private ProcedureModel _SelectProcedure;

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

        private ICamera _Camera;

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

        public string Title => "供料时机设置";
        public Management management { get; set; }
        public IVoiceCoilMotorFeeder Feeder { get; set; }
        #endregion

        #region 命令
        private DelegateCommand _ConfirmCommand;
        public DelegateCommand ConfirmCommand =>
            _ConfirmCommand ?? (_ConfirmCommand = new DelegateCommand(ExecuteConfirmCommand));

        private DelegateCommand _CancelCommand;
        public DelegateCommand CancelCommand =>
            _CancelCommand ?? (_CancelCommand = new DelegateCommand(ExecuteCancelCommand));

        private DelegateCommand _RunBlobToolCommand;
        public DelegateCommand RunBlobToolCommand =>
            _RunBlobToolCommand ?? (_RunBlobToolCommand = new DelegateCommand(ExecuteRunBlobToolCommand));

        private DelegateCommand _SetCurrnetAreaCommand;
        public DelegateCommand SetCurrnetAreaCommand =>
            _SetCurrnetAreaCommand ?? (_SetCurrnetAreaCommand = new DelegateCommand(ExecuteSetCurrnetAreaCommand));

        
        #endregion

        #region 事件
        public event Action<IDialogResult> RequestClose;
        #endregion

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

        #region 方法

        /// <summary>
        /// 确定
        /// </summary>
        void ExecuteConfirmCommand()
        {
            IDialogParameters parameters = new DialogParameters();
            parameters.Add("MinArea", MinArea);
            RequestClose?.Invoke(new DialogResult(ButtonResult.OK, parameters));
        }

        /// <summary>
        /// 取消
        /// </summary>
        void ExecuteCancelCommand()
        {
            IDialogParameters parameters = new DialogParameters();
            parameters.Add("MinArea", 0);
            RequestClose?.Invoke(new DialogResult(ButtonResult.Cancel, parameters));
        }

        /// <summary>
        /// 运行工具
        /// </summary>
        void ExecuteRunBlobToolCommand()
        {
            try
            {
                if (SelectProcedure.ToolBlock != null)
                {
                    SelectProcedure.ToolBlock.Inputs["InputImage"].Value = Camera.Grab();
                    SelectProcedure.ToolBlock.Run();
                    var blobtool = SelectProcedure.ToolBlock.Tools["CogBlobTool1"] as CogBlobTool;
                    blobtool.Run();
                    double totalarea = 0;
                    if (blobtool.Results!=null)
                    {
                        foreach (CogBlobResult item in blobtool.Results.GetBlobs())
                        {
                            totalarea += item.Area;
                        }
                    }
                    BlobTotalArea = totalarea;
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("运行视觉Blob工具时出错！", ex);
                MessageBox.Show(ex.Message);
            }
        }

        void ExecuteSetCurrnetAreaCommand()
        {
            MinArea = BlobTotalArea;
        }

        public bool CanCloseDialog()
        {
            return true;
        }

        public void OnDialogClosed()
        {

        }

        public void OnDialogOpened(IDialogParameters parameters)
        {
            try
            {
                management = _container.Resolve<Management>();
                SelectProcedure = _container.Resolve<ProcessBasicsViewModel>().SelectProcedure;
                MinArea=SelectProcedure.MinArea;
                Feeder = management.FeederService.GetFeeder(SelectProcedure.FeederId);
                Camera = _container.Resolve<Management>().CameraService.GetCamera(SelectProcedure.CameraId);
                BlobEditV2.Subject = SelectProcedure.ToolBlock.Tools["CogBlobTool1"] as CogBlobTool;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder Blob界面出错！", ex);
                MessageBox.Show(ex.Message);
            }
            
        }
        #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;
            }
        }
    }
}