Display_D_HP/TeamAAS-VM/ViewModels/Product/PlcPointParamsViewModel.cs

using Cognex.VisionPro;
using MaterialDesignThemes.Wpf;
using MathNet.Numerics.LinearAlgebra;
using NPOI.SS.Formula.Functions;
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.Drawing;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using TeamAAS_VP.Controls;
using TeamAAS_VP.Core;
using TeamAAS_VP.Core.PLCs;
using TeamAAS_VP.DxfModule;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Events;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Models.PLC;
using TeamAAS_VP.Models.Robot;
using TeamAAS_VP.Resources.Languages;
using TeamAAS_VP.Services;
using TeamAAS_VP.Views.Product;
using static TeamAAS_VP.ViewModels.Product.AutoCorrectLockPointViewModel;

namespace TeamAAS_VP.ViewModels.Product
{
    public class PlcPointParamsViewModel : BindableBase, IConfirmNavigationRequest
    {
        IRegionManager _regionManager;
        IEventAggregator _eventAggregator;
        IContainerProvider _container;
        IDialogService _dialogService;
        IConfigService _configService;
        IRobotService _robotService;
        ISystemDatabaseService _systemDatabaseService;
        IRemoteCommandService _remoteCommandService;
        ICalibrationService _calibrationService;
        ICameraService _cameraService;
        CoordinateTransformer local=null;

        #region 属性

        private ProductModel _SelectProduct;

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

        private PlcPoint _SelectedPoint;
        public PlcPoint SelectedPoint
        {
            get { return _SelectedPoint; }
            set { SetProperty(ref _SelectedPoint, value); }
        }

        private PlcPoint _selectedPointInDataGrid;
        public PlcPoint SelectedPointInDataGrid
        {
            get { return _selectedPointInDataGrid; }
            set
            {
                if (SetProperty(ref _selectedPointInDataGrid, value))
                {
                    SelectedPointInComboBox = value;
                    // update command availability
                    _MovePointUpCommand?.RaiseCanExecuteChanged();
                    _MovePointDownCommand?.RaiseCanExecuteChanged();
                    // 更新依赖可执行状态的命令
                    _TechPointCommand?.RaiseCanExecuteChanged();
                    _ExecuteMotion?.RaiseCanExecuteChanged();
                }
                // 可以同步到 SelectPoint 属性
                SelectedPoint = value;

            }
        }

        private PlcPoint _selectedPointInComboBox;
        public PlcPoint SelectedPointInComboBox
        {
            get { return _selectedPointInComboBox; }
            set
            {
                if (SetProperty(ref _selectedPointInComboBox, value))
                {
                    SelectedPointInDataGrid = value;
                }
                // 可以同步到 SelectPoint 属性
                SelectedPoint = value;

            }
        }

        private ObservableCollection<PlcPoint> _Points = new ObservableCollection<PlcPoint>();
        /// <summary>
        /// 点位集合
        /// </summary>
        public ObservableCollection<PlcPoint> Points
        {
            get { return _Points; }
            set { SetProperty(ref _Points, value); }
        }

        private MotionCommand _SelectMotionCommand;
        /// <summary>
        /// 选中的运动指令
        /// </summary>
        public MotionCommand SelectMotionCommand
        {
            get { return _SelectMotionCommand; }
            set { SetProperty(ref _SelectMotionCommand, value); }
        }

        public Management management { get; set; }

        private IRobot _Robot;

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

            }
        }

        private int _SelectedIndex;
        public int SelectedIndex
        {
            get { return _SelectedIndex; }
            set { SetProperty(ref _SelectedIndex, value); }
        }

        private double _Distance = 1;

        public double Distance
        {
            get { return _Distance; }
            set
            {
                SetProperty(ref _Distance, value);
                try
                {
                    if (Robot == null)
                    {
                        return;
                    }
                    _configService.UpdateRobotStepDistance(Robot.Id, value);
                }
                catch (Exception)
                {

                }
            }
        }

        private ObservableCollection<ProcedureModel> _ProcedureModels;

        /// <summary>
        /// 流程集合
        /// </summary>
        public ObservableCollection<ProcedureModel> ProcedureModels
        {
            get { return _ProcedureModels; }
            set { SetProperty(ref _ProcedureModels, value); }
        }

        private ProcedureModel _SelectProcedure;

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

        private float _LockPointStartZ;
        /// <summary>
        /// 批量设置锁付点的起始Z坐标
        /// </summary>
        public float LockPointStartZ
        {
            get { return _LockPointStartZ; }
            set { SetProperty(ref _LockPointStartZ, value); }
        }

        private float _LockZDepth;
        /// <summary>
        /// 批量设置锁付点Z深度
        /// </summary>
        public float LockZDepth
        {
            get { return _LockZDepth; }
            set { SetProperty(ref _LockZDepth, value); }
        }

        private float _LockXSpeed;
        /// <summary>
        /// 批量设置锁付点X轴速度
        /// </summary>
        public float LockXSpeed
        {
            get { return _LockXSpeed; }
            set { SetProperty(ref _LockXSpeed, value); }
        }

        private float _LockYSpeed;
        /// <summary>
        /// 批量设置锁付点Y轴速度
        /// </summary>
        public float LockYSpeed
        {
            get { return _LockYSpeed; }
            set { SetProperty(ref _LockYSpeed, value); }
        }

        private float _LockZSpeed;
        /// <summary>
        /// 批量设置锁付点Z轴速度
        /// </summary>
        public float LockZSpeed
        {
            get { return _LockZSpeed; }
            set { SetProperty(ref _LockZSpeed, value); }
        }

        private float _LockZDescendSpeed;
        /// <summary>
        /// 批量设置锁付点Z轴下降速度
        /// </summary>
        public float LockZDescendSpeed
        {
            get { return _LockZDescendSpeed; }
            set { SetProperty(ref _LockZDescendSpeed, value); }
        }

        private Int16 _LockFeederNumber;
        /// <summary>
        /// 批量设置锁付点供料器编号
        /// </summary>
        public Int16 LockFeederNumber
        {
            get { return _LockFeederNumber; }
            set { SetProperty(ref _LockFeederNumber, value); }
        }

        private Int16 _LockScrewProgramNumber;
        /// <summary>
        /// 批量设置锁付点螺丝程序编号
        /// </summary>
        public Int16 LockScrewProgramNumber
        {
            get { return _LockScrewProgramNumber; }
            set { SetProperty(ref _LockScrewProgramNumber, value); }
        }

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

        private ObservableCollection<CameraInfo> _CameraList;
        public ObservableCollection<CameraInfo> CameraList
        {
            get { return _CameraList; }
            set { SetProperty(ref _CameraList, value); }
        }

        private CameraInfo _SelectedCamera;
        public CameraInfo SelectedCamera
        {
            get { return _SelectedCamera; }
            set { SetProperty(ref _SelectedCamera, value);
                if (value!=null)
                {
                    if(Camera!=null)
                    {
                        if (Camera.IsGrabbing)
                        {
                            Camera.StopGrabbing();
                        }
                        Camera.ImageCallbackEvent -= Camera_ImageCallbackEvent;
                    }
                    Camera = _cameraService.GetCamera(value.Id);
                    Camera.ImageCallbackEvent += Camera_ImageCallbackEvent;
                }
            }
        }

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

        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 bool _IsLeftDrawerOpen;
        public bool IsLeftDrawerOpen
        {
            get { return _IsLeftDrawerOpen; }
            set { SetProperty(ref _IsLeftDrawerOpen, value);
                if (!value)
                {
                    if (IsGrap)
                    {
                        ExecuteStopGrabbingCommand();
                    }
                }
            }
        }

        #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<object> _ExecuteMotion;
        public DelegateCommand<object> ExecuteMotion =>
            _ExecuteMotion ?? (_ExecuteMotion = new DelegateCommand<object>(ExecuteExecuteMotion).ObservesCanExecute(() => CanExecutePointCommand).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute).ObservesProperty(() => SelectedPointInDataGrid));

        private DelegateCommand<object> _JogCommand;
        public DelegateCommand<object> JogCommand =>
             _JogCommand ?? (_JogCommand = new DelegateCommand<object>(ExecuteJogCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        private DelegateCommand _TechPointCommand;
        public DelegateCommand TechPointCommand =>
            _TechPointCommand ?? (_TechPointCommand = new DelegateCommand(ExecuteTechPointCommand).ObservesCanExecute(() => CanExecutePointCommand).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute).ObservesProperty(() => SelectedPointInDataGrid));

        private DelegateCommand<string> _MotorCommand;
        public DelegateCommand<string> MotorCommand =>
            _MotorCommand ?? (_MotorCommand = new DelegateCommand<string>(ExecuteMotorCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        private DelegateCommand _ResetCommand;
        public DelegateCommand ResetCommand =>
            _ResetCommand ?? (_ResetCommand = new DelegateCommand(ExecuteResetCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        private DelegateCommand _sFreeCommand;
        public DelegateCommand sFreeCommand =>
            _sFreeCommand ?? (_sFreeCommand = new DelegateCommand(ExecutesFreeCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        private DelegateCommand _SLockCommand;
        public DelegateCommand SLockCommand =>
            _SLockCommand ?? (_SLockCommand = new DelegateCommand(ExecuteSLockCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));


        private DelegateCommand _SelectionChangedCommand;
        public DelegateCommand SelectionChangedCommand =>
            _SelectionChangedCommand ?? (_SelectionChangedCommand = new DelegateCommand(ExecuteSelectionChangedCommand));

        private DelegateCommand _AddPointCommand;
        public DelegateCommand AddPointCommand =>
            _AddPointCommand ?? (_AddPointCommand = new DelegateCommand(ExecuteAddPointCommand));

        private DelegateCommand _DeletePointCommand;
        public DelegateCommand DeletePointCommand =>
            _DeletePointCommand ?? (_DeletePointCommand = new DelegateCommand(ExecuteDeletePointCommand, CanExecuteDeletePointCommand).ObservesProperty(() => SelectedPointInDataGrid));

        private DelegateCommand _MovePointUpCommand;
        public DelegateCommand MovePointUpCommand => _MovePointUpCommand ?? (_MovePointUpCommand = new DelegateCommand(ExecuteMovePointUpCommand, CanMovePointUp));

        private DelegateCommand _MovePointDownCommand;
        public DelegateCommand MovePointDownCommand => _MovePointDownCommand ?? (_MovePointDownCommand = new DelegateCommand(ExecuteMovePointDownCommand, CanMovePointDown));

        private DelegateCommand _ImportCadPointCommand;
        public DelegateCommand ImportCadPointCommand =>
            _ImportCadPointCommand ?? (_ImportCadPointCommand = new DelegateCommand(ExecuteImportCadPointCommand));

        private DelegateCommand _ImportCadLockCameraPointCommand;
        public DelegateCommand ImportCadLockCameraPointCommand =>
            _ImportCadLockCameraPointCommand ?? (_ImportCadLockCameraPointCommand = new DelegateCommand(ExecuteImportCadLockCameraPointCommand));

        private DelegateCommand _ApplyLockPointStartZCommand;
        public DelegateCommand ApplyLockPointStartZCommand =>
            _ApplyLockPointStartZCommand ?? (_ApplyLockPointStartZCommand = new DelegateCommand(ExecuteApplyLockPointStartZCommand));

        private DelegateCommand _ApplyLockPointDepthCommand;
        public DelegateCommand ApplyLockPointDepthCommand =>
            _ApplyLockPointDepthCommand ?? (_ApplyLockPointDepthCommand = new DelegateCommand(ExecuteApplyLockPointDepthCommand));

        private DelegateCommand _ApplyLockPointSpeedCommand;
        public DelegateCommand ApplyLockPointSpeedCommand =>
            _ApplyLockPointSpeedCommand ?? (_ApplyLockPointSpeedCommand = new DelegateCommand(ExecuteApplyLockPointSpeedCommand));

        private DelegateCommand _ApplyLockPointFeederAndScrewProgramCommand;
        public DelegateCommand ApplyLockPointFeederAndScrewProgramCommand =>
            _ApplyLockPointFeederAndScrewProgramCommand ?? (_ApplyLockPointFeederAndScrewProgramCommand = new DelegateCommand(ExecuteApplyLockPointFeederAndScrewProgramCommand));

        private DelegateCommand _AutoCorrectLockPointCommand;
        public DelegateCommand AutoCorrectLockPointCommand =>
            _AutoCorrectLockPointCommand ?? (_AutoCorrectLockPointCommand = new DelegateCommand(ExecuteAutoCorrectLockPoint));

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

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

        private DelegateCommand _DynamicTestAnalyzerCommand;
        public DelegateCommand DynamicTestAnalyzerCommand =>
            _DynamicTestAnalyzerCommand ?? (_DynamicTestAnalyzerCommand = new DelegateCommand(ExecuteDynamicTestAnalyzerCommand));

        
        #endregion

        #region 事件

        #endregion

        public PlcPointParamsViewModel(IRegionManager regionManager, IEventAggregator ea, IContainerProvider container, IDialogService dialogService,
            IConfigService configService, IRobotService robotService, ISystemDatabaseService systemDatabaseService, IRemoteCommandService remoteCommandService,
            ICalibrationService calibrationService, ICameraService cameraService)
        {
            _regionManager = regionManager;
            _eventAggregator = ea;
            _container = container;
            _dialogService = dialogService;
            _configService = configService;
            _systemDatabaseService = systemDatabaseService;
            //订阅权限登录事件
            _eventAggregator.GetEvent<UserLoginNotification>().Subscribe(LoginChange);
            management = _container.Resolve<Management>();
            _robotService = robotService;
            _remoteCommandService = remoteCommandService;
            _calibrationService = calibrationService;
            _cameraService = cameraService;
        }

        #region 方法

        /// <summary>
        /// 下一步
        /// </summary>
        void ExecuteNextCommand()
        {
            NavigationParameters param = new NavigationParameters();
            param.Add("SelectProduct", SelectProduct);
            _regionManager.RequestNavigate("ProductRegionContext", "ProductParams", param);
        }

        /// <summary>
        /// 上一步
        /// </summary>
        void ExecuteBackCommand()
        {
            NavigationParameters param = new NavigationParameters();
            param.Add("SelectProduct", SelectProduct);
            param.Add("SelectedProcedure", null);
            _regionManager.RequestNavigate("ProductRegionContext", "ProcessBasics", param);
        }

        /// <summary>
        /// 点动
        /// </summary>
        /// <param name="obj"></param>
        private async void ExecuteJogCommand(object obj)
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                var items = ((string)obj).Split(':');
                //如果移动距离大于10mm，则提示用户确认
                double distance = double.Parse(items[1]);
                if (Math.Abs(distance) >= 10)
                {
                    if (MessageBox.Show(string.Format(Lang.确认要点动距离0mm吗, distance), Lang.确认点动, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                    {
                        return;
                    }
                }

                Robot.Timeout = 6000000;

                switch (items[0])
                {
                    case "X+":
                        await Robot.JogAsync("X", distance);
                        break;
                    case "X-":
                        await Robot.JogAsync("X", -distance);
                        break;
                    case "Y+":
                        await Robot.JogAsync("Y", distance);
                        break;
                    case "Y-":
                        await Robot.JogAsync("Y", -distance);
                        break;
                    case "Z+":
                        await Robot.JogAsync("Z", distance);
                        break;
                    case "Z-":
                        await Robot.JogAsync("Z", -distance);
                        break;
                    case "U+":
                        await Robot.JogAsync("U", distance);
                        break;
                    case "U-":
                        await Robot.JogAsync("U", -distance);
                        break;
                    case "V+":
                        await Robot.JogAsync("V", distance);
                        break;
                    case "V-":
                        await Robot.JogAsync("V", -distance);
                        break;
                    case "W+":
                        await Robot.JogAsync("W", distance);
                        break;
                    case "W-":
                        await Robot.JogAsync("W", -distance);
                        break;
                    default:
                        break;
                }
                Robot.Timeout = 5000;

                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });

            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.机器人点位机器人点动时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 执行运动
        /// </summary>
        /// <param name="obj"></param>
        async void ExecuteExecuteMotion(object parameter)
        {
            if (parameter == null)
            {
                return;
            }
            if (SelectedPoint == null)
            {
                return;
            }
            var values = (object[])parameter;
            var point = new RPoint()
            {
                X = SelectedPoint.X_Position,
                Y = SelectedPoint.Y_Position,
                Z = SelectedPoint.Z_Position_Start,
                U = SelectedPoint.U_Position,
                V = SelectedPoint.R_Position,
            };
            MotionCommand motionCmd = (MotionCommand)values[1];
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                if (SelectedIndex == 4)
                {
                    await ExecuteAutoCorrectLockPointAndExecuteCommand(SelectedPoint);
                }
                else
                {
                    //确认要执行该点位的该运动指令吗
                    if (MessageBox.Show(string.Format(Lang.确认要执行点位0的1指令吗, SelectedPoint.Number, motionCmd), Lang.执行点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                    {
                        return;
                    }

                    //Robot.Timeout = 6000000;
                    switch (motionCmd)
                    {
                        case MotionCommand.Go:
                            await Robot.GoAsync(point);
                            break;
                        case MotionCommand.Jump:
                            await Robot.JumpAsync(point, 0);
                            break;
                        case MotionCommand.Move:
                            await Robot.MoveAsync(point);
                            break;
                    }
                    //Robot.Timeout = 5000;
                }    
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.机器人点位执行点位时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 示教点位
        /// </summary>
        /// <param name="point"></param>
        async void ExecuteTechPointCommand()
        {
            if (Robot == null || !Robot.IsConnected) return;
            if (SelectedPoint == null) return;

            try
            {
                //如果当前的选项卡处于锁付点位，则提示用户当前模式不允许进行示教
                if (SelectedIndex == 4)
                {
                    //如果local为空，则必须先通过相机定位产品，否则无法示教锁付点位
                    if (local == null)
                    {
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.当前模式不允许直接示教锁付点位请先通过相机定位产品, Duration = 1 });
                        return;
                    }

                    //弹窗用户是否确认要示教该点位
                    if (MessageBox.Show(string.Format(Lang.确认要示教点位0吗,SelectedPoint.Number), Lang.示教点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                    {
                        return;
                    }

                    var curpos1 = await Robot.GetRobotPosAsync();
                    //将当前点位转换为产品Local坐标系下的点位
                    var localPoint = local.ToNewCoord(curpos1.X, curpos1.Y);
                    SelectedPoint.X_Position = (float)localPoint[0];
                    SelectedPoint.Y_Position = (float)localPoint[1];
                    SelectedPoint.Z_Position_Start = curpos1.Z;
                    SelectedPoint.U_Position = curpos1.U;
                    SelectedPoint.R_Position = curpos1.V;
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                    return;
                }
                else
                {
                    //弹窗用户是否确认要示教该点位
                    if (MessageBox.Show(string.Format(Lang.确认要示教点位0吗, SelectedPoint.Number), Lang.示教点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                    {
                        return;
                    }

                    var curpos = await Robot.GetRobotPosAsync();
                    SelectedPoint.X_Position = curpos.X;
                    SelectedPoint.Y_Position = curpos.Y;
                    SelectedPoint.Z_Position_Start = curpos.Z;
                    SelectedPoint.U_Position = curpos.U;
                    SelectedPoint.R_Position = curpos.V;
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.机器人点位示教点位时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        void ExecuteLoadedCommand()
        {
            if (_systemDatabaseService.GetCurrentUser().userPart == Enums.UserPart.Operator)
            {
                IsAllowEdit = false;
            }
            else
            {
                IsAllowEdit = true;
            }
        }

        /// <summary>
        /// 电机
        /// </summary>
        /// <param name="obj"></param>
        private async void ExecuteMotorCommand(string obj)
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                await Robot.MotorAsync(Convert.ToBoolean(obj));
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.机器人点击操作时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 重置
        /// </summary>
        private async void ExecuteResetCommand()
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                await Robot.ResetAsync();
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.重置机器人时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 锁定刹车
        /// </summary>
        private async void ExecuteSLockCommand()
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                await Robot.SLockAsync();
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.机器人锁定刹车时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 释放刹车
        /// </summary>
        private async void ExecutesFreeCommand()
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                await Robot.SFreeAsync();
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.机器人释放刹车时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        private bool CanExecute
        {
            get
            {
                // 命令可执行仅当机器人可执行且已选择点位
                if (Robot != null && Robot.IsConnected && Robot.CanExecute)
                {
                    return true;
                }
                return false;
            }
        }

        //是否可以示教或者执行点位
        private bool CanExecutePointCommand
        {
            get
            {
                if (Robot != null && Robot.IsConnected && Robot.CanExecute)
                {
                    return SelectedPointInDataGrid != null;
                }
                return false;
            }
        }

        /// <summary>
        /// 点位表切换时
        /// </summary>
        void ExecuteSelectionChangedCommand()
        {
            switch (SelectedIndex)
            {
                case 0:

                    Points = SelectProduct.PickCameraPoints;
                    PickPoints = SelectProduct.PickPoints;
                    break;
                case 1:
                    Points = SelectProduct.PickPoints;
                    break;
                case 2:
                    Points = SelectProduct.SecPosCameraPoints;
                    break;
                case 3:
                    Points = SelectProduct.ScrewCameraPoints;
                    break;
                case 4:
                    Points = SelectProduct.ScrewPoints;
                    break;
                case 5:
                    Points = SelectProduct.CheckCameraPoints;
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 增加点位
        /// </summary>
        void ExecuteAddPointCommand()
        {
            //添加点位
            Points.Add(new PlcPoint()
            {
                Number = Points.Count + 1,
                X_Velocity = 100,
                Y_Velocity = 100,
                Z_Velocity_Start = 100,
                Z_Velocity_Stop = 100,
                U_Velocity = 100,
                R_Velocity = 100,
            });
            // update commands
            _MovePointUpCommand?.RaiseCanExecuteChanged();
            _MovePointDownCommand?.RaiseCanExecuteChanged();
        }

        /// <summary>
        /// 移除点位
        /// </summary>
        void ExecuteDeletePointCommand()
        {
            if (SelectedPoint == null)
            {
                return;
            }
            // 确认删除
            if (MessageBox.Show(Lang.确认要删除选中的点位吗, Lang.删除点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
            {
                return;
            }
            int removedIndex = Points.IndexOf(SelectedPoint);
            Points.Remove(SelectedPoint);
            //重新编号
            for (int i = 0; i < Points.Count; i++)
            {
                Points[i].Number = i + 1;
            }
            // adjust selection
            if (Points.Count > 0)
            {
                int newIndex = Math.Min(removedIndex, Points.Count - 1);
                SelectedPointInDataGrid = Points[newIndex];
            }
            else
            {
                SelectedPointInDataGrid = null;
            }
            // update commands
            _MovePointUpCommand?.RaiseCanExecuteChanged();
            _MovePointDownCommand?.RaiseCanExecuteChanged();
        }

        bool CanExecuteDeletePointCommand()
        {
            return SelectedPointInDataGrid != null;
        }

        private bool CanMovePointUp()
        {
            return SelectedPointInDataGrid != null && Points.IndexOf(SelectedPointInDataGrid) > 0;
        }

        private bool CanMovePointDown()
        {
            return SelectedPointInDataGrid != null && Points.IndexOf(SelectedPointInDataGrid) >= 0 && Points.IndexOf(SelectedPointInDataGrid) < Points.Count - 1;
        }

        /// <summary>
        /// 向上移动点位
        /// </summary>
        void ExecuteMovePointUpCommand()
        {
            if (SelectedPointInDataGrid == null) return;
            // 确认移动
            if (MessageBox.Show(Lang.确认将选中点位上移一位吗, Lang.移动点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
            {
                return;
            }
            int idx = Points.IndexOf(SelectedPointInDataGrid);
            if (idx <= 0) return;
            var item = SelectedPointInDataGrid;
            Points.Move(idx, idx - 1);
            // renumber
            for (int i = 0; i < Points.Count; i++) Points[i].Number = i + 1;
            SelectedPointInDataGrid = item;
            _MovePointUpCommand?.RaiseCanExecuteChanged();
            _MovePointDownCommand?.RaiseCanExecuteChanged();
        }

        /// <summary>
        /// 向下移动点位
        /// </summary>
        void ExecuteMovePointDownCommand()
        {
            if (SelectedPointInDataGrid == null) return;
            // 确认移动
            if (MessageBox.Show(Lang.确认将选中点位下移一位吗, Lang.移动点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
            {
                return;
            }
            int idx = Points.IndexOf(SelectedPointInDataGrid);
            if (idx < 0 || idx >= Points.Count - 1) return;
            var item = SelectedPointInDataGrid;
            Points.Move(idx, idx + 1);
            // renumber
            for (int i = 0; i < Points.Count; i++) Points[i].Number = i + 1;
            SelectedPointInDataGrid = item;
            _MovePointUpCommand?.RaiseCanExecuteChanged();
            _MovePointDownCommand?.RaiseCanExecuteChanged();
        }

        /// <summary>
        /// CAD导入点位
        /// </summary>
        async void ExecuteImportCadPointCommand()
        {
            try
            {
                var view = new DxfView();

                //show the dialog
                var result = await DialogHost.Show(view, "RootDialog", null, null, null);
                if (result != null)
                {
                    var cadPoints = view.Points;
                    if (cadPoints != null && cadPoints.Count > 0)
                    {
                        //要导入的开始点编号
                        int startNumber = view.StartIndex;

                        //弹窗提示用户是否确认要导入从该编号开始的点位，点位数量为cadPoints.Count
                        if (MessageBox.Show(string.Format(Lang.确认要从点位编号0开始导入1个点位吗, startNumber,cadPoints.Count), Lang.导入点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                        {
                            return;
                        }
                        //导入点位
                        for (int i = 0; i < cadPoints.Count; i++)
                        {
                            //如果点位编号已存在，则更新该点位，否则新增点位，只更新XY坐标
                            var point = cadPoints[i];
                            var existingPoint = Points.FirstOrDefault(p => p.Number == startNumber + i);
                            if (existingPoint != null)
                            {
                                existingPoint.X_Position = point.X;
                                existingPoint.Y_Position = point.Y;

                            }
                            else
                            {
                                Points.Add(new PlcPoint()
                                {
                                    Number = startNumber + i,
                                    X_Position = point.X,
                                    Y_Position = point.Y,
                                    X_Velocity = 100,
                                    Y_Velocity = 100,
                                    Z_Velocity_Start = 100,
                                    Z_Velocity_Stop = 100,
                                    U_Velocity = 100,
                                    R_Velocity = 100,
                                });
                            }
                        }

                        //对所有的点位重新编号，确保编号连续
                        var sortedPoints = Points.OrderBy(p => p.Number).ToList();
                        Points.Clear();
                        for (int i = 0; i < sortedPoints.Count; i++)
                        {
                            sortedPoints[i].Number = i + 1;
                            Points.Add(sortedPoints[i]);
                        }
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.导入CAD点位时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 导入锁付拍照引导的产品坐标系中的点位
        /// </summary>
        async void ExecuteImportCadLockCameraPointCommand()
        {
            try
            {
                var view = new DxfView();

                //show the dialog
                var result = await DialogHost.Show(view, "RootDialog", null, null, null);
                if (result != null)
                {
                    var cadPoints = view.Points;
                    if (cadPoints != null && cadPoints.Count == 2)
                    {
                        //弹窗提示用户是否确认要导入锁付拍照引导的起始点和结束点
                        if (MessageBox.Show(Lang.确认要导入锁付拍照引导的起始点和结束点吗, Lang.导入点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                        {
                            return;
                        }
                        //导入点位
                        //起始点
                        var startPoint = cadPoints[0];
                        SelectProduct.ScrewCameraLocalPos1.X_Position = startPoint.X;
                        SelectProduct.ScrewCameraLocalPos1.Y_Position = startPoint.Y;

                        //结束点
                        var endPoint = cadPoints[1];
                        SelectProduct.ScrewCameraLocalPos2.X_Position = endPoint.X;
                        SelectProduct.ScrewCameraLocalPos2.Y_Position = endPoint.Y;

                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                    }
                    else
                    {
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.请导入两个点分别为锁付拍照引导的起始点和结束点, Duration = 1 });
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.导入CAD点位时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 批量设置锁付点的供料器编号和螺丝程序编号
        /// </summary>
        void ExecuteApplyLockPointFeederAndScrewProgramCommand()
        {
            //检查供料器编号和螺丝程序编号是否大于0，如果小于等于0，则提示用户编号是否正确，是否继续写入
            if (LockFeederNumber <= 0 || LockScrewProgramNumber <= 0)
            {
                var result = MessageBox.Show(Lang.供料器编号或螺丝程序编号小于等于0是否继续写入, Lang.确认, MessageBoxButton.YesNo, MessageBoxImage.Question);
                if (result != MessageBoxResult.Yes)
                {
                    return;
                }
            }

            //遍历所有点位，设置供料器编号和螺丝程序编号
            foreach (var point in Points)
            {
                point.Feeder = LockFeederNumber;
                point.ScrewProNum = LockScrewProgramNumber;
            }
        }

        /// <summary>
        /// 批量设置锁付点的速度
        /// </summary>
        void ExecuteApplyLockPointSpeedCommand()
        {
            //检查速度是否大于0，如果小于等于0，则提示用户速度是否正确，是否继续写入
            if (LockXSpeed <= 0 || LockYSpeed <= 0 || LockZSpeed <= 0 || LockZDescendSpeed <= 0)
            {
                var result = MessageBox.Show(Lang.速度小于等于0是否继续写入, Lang.确认, MessageBoxButton.YesNo, MessageBoxImage.Question);
                if (result != MessageBoxResult.Yes)
                {
                    return;
                }
            }

            //遍历所有点位，设置速度
            foreach (var point in Points)
            {
                point.X_Velocity = LockXSpeed;
                point.Y_Velocity = LockYSpeed;
                point.Z_Velocity_Start = LockZSpeed;
                point.Z_Velocity_Stop = LockZDescendSpeed;
            }
        }

        /// <summary>
        /// 批量设置锁付点的Z深度
        /// </summary>
        void ExecuteApplyLockPointDepthCommand()
        {
            //检查深度是否大于0，如果小于等于0，则提示用户深度是否正确，是否继续写入
            if (LockZDepth <= 0)
            {
                var result = MessageBox.Show(Lang.深度小于等于0是否继续写入, Lang.确认, MessageBoxButton.YesNo, MessageBoxImage.Question);
                if (result != MessageBoxResult.Yes)
                {
                    return;
                }
            }

            //遍历所有点位，设置Z深度
            foreach (var point in Points)
            {
                point.Z_Position_Stop = point.Z_Position_Start - LockZDepth;
            }
        }

        /// <summary>
        /// 批量设置锁付点的起始Z坐标
        /// </summary>
        void ExecuteApplyLockPointStartZCommand()
        {
            //检查起始Z坐标是否小于0，如果大于等于0，则提示用户坐标是否正确，是否继续写入
            if (LockPointStartZ >= 0)
            {
                var result = MessageBox.Show(Lang.起始Z坐标大于等于0是否继续写入, Lang.确认, MessageBoxButton.YesNo, MessageBoxImage.Question);
                if (result != MessageBoxResult.Yes)
                {
                    return;
                }
            }

            //遍历所有点位，设置起始Z坐标
            foreach (var point in Points)
            {
                point.Z_Position_Start = LockPointStartZ;
            }

            //检查终点坐标是否小于等于起始坐标，如果不是，则提示用户终点坐标大于等于起始坐标，用户需要去调整终点坐标
            foreach (var point in Points)
            {
                if (point.Z_Position_Stop >= point.Z_Position_Start)
                {
                    MessageBox.Show(string.Format(Lang.点位编号0的终点坐标大于等于起始坐标请调整终点坐标, point.Number ), Lang.警告, MessageBoxButton.OK, MessageBoxImage.Warning);
                }
            }

        }

        /// <summary>
        /// 通过相机自动矫正锁附点位
        /// </summary>
        async void ExecuteAutoCorrectLockPoint()
        {
            try
            {
                if (Camera != null)
                {
                    if (Camera.IsGrabbing)
                    {
                        ExecuteStopGrabbingCommand();
                    }
                }
                //弹窗提示用户是否确认要通过相机自动矫正锁附点位
                var resultConfirm = MessageBox.Show(Lang.确认要通过相机自动矫正锁附点位吗, Lang.确认, MessageBoxButton.YesNo, MessageBoxImage.Question);
                if (resultConfirm != MessageBoxResult.Yes)
                {
                    return;
                }
                //获取螺丝相机拍照点位
                var screwCameraPoint = SelectProduct.ScrewCameraPoints;
                //获取相机拍照点对应的LocalPos
                var screwCameraLocalPos1 = SelectProduct.ScrewCameraLocalPos1;
                var screwCameraLocalPos2 = SelectProduct.ScrewCameraLocalPos2;
                //获取螺丝锁付点位
                var screwLockPoints = SelectProduct.ScrewPoints;
                //检查screwLockPoints中是否有和screwCameraLocalPos1的XY坐标相同的点位
                var matchingPoint = screwLockPoints.FirstOrDefault(p => p.X_Position == screwCameraLocalPos1.X_Position && p.Y_Position == screwCameraLocalPos1.Y_Position);
                if (matchingPoint != null)
                {
                    //检查两个点位的Z是否一致？如果不一致，则提示用户锁付点位中有和锁付拍照引导起始点Local坐标相同的点位，且Z坐标不一致，是否将锁付拍照引导起始点Local坐标的Z轴坐标更新为锁付点位的Z坐标
                    if (matchingPoint.Z_Position_Start != screwCameraLocalPos1.Z_Position_Start)
                    {
                        var resultUpdateZ = MessageBox.Show(Lang.锁付点位中有和锁付拍照引导起始点Local坐标相同的点位且Z坐标不一致是否将锁付拍照引导起始点Local坐标的Z轴坐标更新为锁付点位的Z坐标, Lang.确认, MessageBoxButton.YesNo, MessageBoxImage.Question);
                        if (resultUpdateZ == MessageBoxResult.Yes)
                        {
                            screwCameraLocalPos1.Z_Position_Start = matchingPoint.Z_Position_Start;
                        }
                    }
                }
                //检查screwLockPoints中是否有和screwCameraLocalPos2的XY坐标相同的点位
                matchingPoint = screwLockPoints.FirstOrDefault(p => p.X_Position == screwCameraLocalPos2.X_Position && p.Y_Position == screwCameraLocalPos2.Y_Position);
                if (matchingPoint != null)
                {
                    //检查两个点位的Z是否一致？如果不一致，则提示用户锁付点位中有和锁付拍照引导结束点Local坐标相同的点位，且Z坐标不一致，是否将锁付拍照引导结束点Local坐标的Z轴坐标更新为锁付点位的Z坐标
                    if (matchingPoint.Z_Position_Start != screwCameraLocalPos2.Z_Position_Start)
                    {
                        var resultUpdateZ = MessageBox.Show(Lang.锁付点位中有和锁付拍照引导结束点Local坐标相同的点位且Z坐标不一致是否将锁付拍照引导结束点Local坐标的Z轴坐标更新为锁付点位的Z坐标, Lang.确认, MessageBoxButton.YesNo, MessageBoxImage.Question);
                        if (resultUpdateZ == MessageBoxResult.Yes)
                        {
                            screwCameraLocalPos2.Z_Position_Start = matchingPoint.Z_Position_Start;
                        }
                    }
                }


                IDialogParameters parameters = new DialogParameters();
                parameters.Add("Robot", Robot);
                parameters.Add("SelectProduct", SelectProduct);
                parameters.Add("Points", new List<PlcPoint>(SelectProduct.ScrewPoints.ToArray()));
                _dialogService.Show("AutoCorrectLockPoint", parameters, rst =>
                {
                    //对话框关闭之后的回调函数，可以在这解析结果。
                    ButtonResult result1 = rst.Result;

                    if (result1 == ButtonResult.OK)
                    {
                        var param = rst.Parameters.GetValue<ObservableCollection<PointEx>>("CorrectPoints");
                        var local1= rst.Parameters.GetValue<CoordinateTransformer>("Local");
                        if (local1!=null)
                        {
                            local = local1;
                        }
                        for (int i = 0; i < SelectProduct.ScrewPoints.Count; i++)
                        {
                            SelectProduct.ScrewPoints[i].X_Position = param[i].PostX;
                            SelectProduct.ScrewPoints[i].Y_Position = param[i].PostY;
                        }

                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.完成, Duration = 1 });
                    }

                });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.通过相机自动矫正锁附点位时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 通过相机先定位产品再执行锁付点位
        /// </summary>
        /// <param name="point"></param>
        private async Task ExecuteAutoCorrectLockPointAndExecuteCommand(PlcPoint point)
        {
            var waiting = new WaitingControl();
            Task<object> task;
            try
            {
                if (Camera != null)
                {
                    if (Camera.IsGrabbing)
                    {
                        ExecuteStopGrabbingCommand();
                    }
                }
                if (Robot == null || !Robot.IsConnected) return;
                //弹窗提示用户是否确认要通过相机自动矫正锁附点位并执行该点位
                var resultConfirm = MessageBox.Show(string.Format(Lang.确认要通过相机自动矫正锁附点位并执行点位0吗, point.Number), Lang.确认, MessageBoxButton.YesNo, MessageBoxImage.Question);
                if (resultConfirm != MessageBoxResult.Yes)
                {
                    return;
                }


                if (Robot == null || !Robot.IsConnected)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.机器人未连接无法执行取料拍照点位矫正, Duration = 1 });
                    return;
                }
                //获取当前产品
                var product = SelectProduct;
                if (product == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.未选择产品无法执行取料拍照点位矫正, Duration = 1 });
                    return;
                }


                
                //如果当前Local为空，则自动进行锁付点位的Local计算
                if (local == null)
                {
                    //show the dialog
                    task = DialogHost.Show(waiting, "RootDialog", null, null, null);
                    var isCalibSucceed = await AutoCalibLockPointLocal(product);
                    if (!isCalibSucceed)
                    {
                        return;
                    }
                }
                else
                {
                    //提示用户，当前系统检测到进入此界面后已经进行过相机产品定位并计算过Local，是否继续使用该Local进行锁付点位的转换计算
                    var resultUseExistingLocal = MessageBox.Show(Lang.系统检测到进入此界面后已经进行过相机产品定位并计算过Local是否继续使用该Local进行锁付点位的转换计算点击是继续使用点击否则重新进行锁付点位的Local计算, Lang.确认, MessageBoxButton.YesNo, MessageBoxImage.Question);
                    if (resultUseExistingLocal == MessageBoxResult.No)
                    {
                        //show the dialog
                        task = DialogHost.Show(waiting, "RootDialog", null, null, null);
                        var isCalibSucceed = await AutoCalibLockPointLocal(product);
                        if (!isCalibSucceed)
                        {
                            return;
                        }
                    }
                    else
                    {
                        //show the dialog
                        task = DialogHost.Show(waiting, "RootDialog", null, null, null);
                    }
                }

                //将锁付点位转换到世界坐标系
                var localPoint = new PointF(point.X_Position, point.Y_Position);
                var worldPoint = local.ToOldCoord(localPoint.X, localPoint.Y);
                var point1 = point.Clone();
                point1.X_Position = (float)worldPoint[0];
                point1.Y_Position = (float)worldPoint[1];
                //执行该点位
                //移动机器人至拍照点位，拍照
                var rpoint = new RPoint()
                {
                    X = point1.X_Position,
                    Y = point1.Y_Position,
                    Z = point1.Z_Position_Start,
                };
                await Robot.CalibMotionAsync(rpoint, 0);

                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.完成, Duration = 1 });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.通过相机自动矫正锁附点位并执行时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
            finally
            {
                try
                {
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                }
                catch (Exception)
                {

                }
            }
        }

        /// <summary>
        /// 移动相机拍产品两个Msrk点计算Local
        /// </summary>
        /// <param name="product"></param>
        /// <returns></returns>
        private async Task<bool> AutoCalibLockPointLocal(ProductModel product)
        {
            try
            {
                //获取锁付相机拍照点位
                var screwCameraPoint = product.ScrewCameraPoints;
                if (screwCameraPoint == null || screwCameraPoint.Count < 2)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.未获取到锁付相机拍照点位无法执行取料拍照点位矫正, Duration = 1 });
                    return false;
                }
                //获取相机拍照点位对应的锁付点
                var screwCameraLocalPoint1 = product.ScrewCameraLocalPos1;
                if (screwCameraLocalPoint1 == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.未获取到锁付相机拍照点位对应的锁付点无法执行取料拍照点位矫正, Duration = 1 });
                    return false;
                }
                var screwCameraLocalPoint2 = product.ScrewCameraLocalPos2;
                if (screwCameraLocalPoint2 == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.未获取到锁付相机拍照点位对应的锁付点无法执行取料拍照点位矫正, Duration = 1 });
                    return false;
                }
                var ProcedureModels = new ObservableCollection<ProcedureModel>();
                foreach (var item in product.CameraProcedures)
                {
                    foreach (var item1 in item.ProcedureModels)
                    {
                        ProcedureModels.Add(item1);
                    }
                }
                //获取拍照流程
                if (product.MoveDownCameraLockPhotoProcedureId == Guid.Empty)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.未获取到锁付相机拍照流程无法执行取料拍照点位矫正, Duration = 1 });
                    return false;
                }
                var procedure = ProcedureModels.FirstOrDefault(p => p.Id == product.MoveDownCameraLockPhotoProcedureId);
                if (procedure == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.未获取到锁付相机拍照流程无法执行取料拍照点位矫正, Duration = 1 });
                    return false;
                }

                CancellationTokenSource _cts = new CancellationTokenSource();
                //移动机器人至拍照点位，拍照
                var rpoint = new RPoint()
                {
                    X = screwCameraPoint[0].X_Position,
                    Y = screwCameraPoint[0].Y_Position,
                    Z = screwCameraPoint[0].Z_Position_Start,
                    U = screwCameraPoint[0].U_Position,
                    V = screwCameraPoint[0].R_Position,
                };
                await Robot.CalibMotionAsync(rpoint, 0);
                await Task.Delay(200);
                // 执行拍照并获取识别结果
                var recognitionResult = await _remoteCommandService.ExecutePhotoGetSinglePointWithImage(procedure, null, new double[] { rpoint.X, rpoint.Y, 0 }, _cts.Token);
                //var Image = recognitionResult.Image;
                //var Graphic = null;
                //var Graphic = recognitionResult.Graphic;
                if (!recognitionResult.IsSucceed)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.拍照获取识别结果失败无法执行取料拍照点位矫正, Duration = 1 });
                    return false;
                }
                //第一个点位的校正结果
                PointF worldP1 = new PointF((float)recognitionResult.X, (float)recognitionResult.Y);
                //移动机器人至拍照点位，拍照
                rpoint = new RPoint()
                {
                    X = screwCameraPoint[1].X_Position,
                    Y = screwCameraPoint[1].Y_Position,
                    Z = screwCameraPoint[1].Z_Position_Start,
                    U = screwCameraPoint[1].U_Position,
                    V = screwCameraPoint[1].R_Position,
                };
                await Robot.CalibMotionAsync(rpoint, 0);
                if (_cts.IsCancellationRequested)
                    return false;
                await Task.Delay(200);
                // 执行拍照并获取识别结果
                recognitionResult = await _remoteCommandService.ExecutePhotoGetSinglePointWithImage(procedure, null, new double[] { rpoint.X, rpoint.Y, 0 }, _cts.Token);
                //Image = recognitionResult.Image;
                //Graphic = null;
                //Graphic = recognitionResult.Graphic;
                if (!recognitionResult.IsSucceed)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.拍照获取识别结果失败无法执行取料拍照点位矫正, Duration = 1 });
                    return false;
                }
                //第一个点位的校正结果
                PointF worldP2 = new PointF((float)recognitionResult.X, (float)recognitionResult.Y);

                //计算移动相机与拍照点之间的偏差
                //获取校准
                var calibration = _calibrationService.GetCalibration(procedure.CalibrationId);

                //获取mark点
                var mark = calibration.MarkPoint;
                //获取中心点
                var center = calibration.CenterPoint;
                //计算相机中心与披头之间的坐标偏差
                var cameraOffsetX = mark.X - center.X;
                var cameraOffsetY = mark.Y - center.Y;


                //根据UpCameraPutResults[]中的索引1、2，和拍照点对应的Local下的坐标，从创建Local坐标系
                PointF localP1 = new PointF(screwCameraLocalPoint1.X_Position, screwCameraLocalPoint1.Y_Position);
                PointF localP2 = new PointF(screwCameraLocalPoint2.X_Position, screwCameraLocalPoint2.Y_Position);
                local = new CoordinateTransformer(worldP1, worldP2, localP1, localP2);
                return true;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.计算锁付点位产品坐标系坐标时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
                return false;
            }
        }

        /// <summary>
        /// 动态测试分析仪
        /// </summary>
        void ExecuteDynamicTestAnalyzerCommand()
        {
            try
            {
                IDialogParameters parameters = new DialogParameters();
                parameters.Add("SelectProduct", SelectProduct);
                parameters.Add("Robot", Robot);
                _dialogService.Show("VisionDynamicAccuracyAnalyzer", parameters, rst =>
                {
                    //对话框关闭之后的回调函数，可以在这解析结果。
                    ButtonResult result1 = rst.Result;

                    if (result1 == ButtonResult.OK)
                    {
                        //var param = rst.Parameters.GetValue<RobotTool>("Tool");
                        //var param1 = rst.Parameters.GetValue<Matrix<double>>("RobotCameraRotationMatrix");
                        //var param2 = rst.Parameters.GetValue<double>("Angle");
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.完成, Duration = 1 });
                    }

                });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("执行动态测试分析仪命令时出错", ex);
                MessageBox.Show(ex.Message);
            }
        }

        /// <summary>
        /// 停止采集
        /// </summary>
        void ExecuteStopGrabbingCommand()
        {
            
            if (Camera != null)
                Camera.StopGrabbing();
            IsGrap = false;
        }

        bool CanExecuteStopGrabbingCommand()
        {
            return IsGrap;
        }

        /// <summary>
        /// 开始采集
        /// </summary>
        void ExecuteStartGrabbingCommand()
        {
            if (Camera != null)
                Camera.StartGrabbing();
            IsGrap = true;
        }
        bool CanExecuteStartGrabbingCommand()
        {
            return SelectedCamera != null && !IsGrap;
        }

        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";
                     }
                 }));
        }
        #endregion

        #region 继承
        /// <summary>
        /// 确认导航请求时调用。此方法允许您在导航之前执行一些操作。
        /// </summary>
        /// <param name="navigationContext"></param>
        /// <param name="continuationCallback"></param>
        public void ConfirmNavigationRequest(NavigationContext navigationContext, Action<bool> continuationCallback)
        {
            continuationCallback(true);
        }

        /// <summary>
        /// 接收导航请求时调用。传入导航参数，包含有关导航目标的信息。
        /// </summary>
        /// <param name="navigationContext"></param>
        /// <exception cref="NotImplementedException"></exception>
        public async void OnNavigatedTo(NavigationContext navigationContext)
        {
            try
            {
                local = null;
                SelectProduct = navigationContext.Parameters.GetValue<ProductModel>("SelectProduct");

                SelectedIndex = 0;
                PickPoints = SelectProduct.PickPoints;
                Points = SelectProduct.PickCameraPoints;

                if (Robot == null)
                {
                    Robot = _robotService.GetRobotByNumber(1);
                }

                if (Robot != null && Robot.IsConnected)
                {
                    this.Distance = _configService.GetRobotStepDistance(Robot.Id);
                    Robot.EnterDebugMode = true;
                }
                else if (Robot != null)
                {
                    Robot.EnterDebugMode = true;
                }
                ProcedureModels = new ObservableCollection<ProcedureModel>();
                foreach (var item in SelectProduct.CameraProcedures)
                {
                    foreach (var item1 in item.ProcedureModels)
                    {
                        ProcedureModels.Add(item1);
                    }
                }

                //对锁付点的批量设置进行初始化
                LockPointStartZ = SelectProduct.ScrewPoints.FirstOrDefault()?.Z_Position_Start ?? 0;
                LockZDepth = SelectProduct.ScrewPoints.FirstOrDefault() != null ? (SelectProduct.ScrewPoints.FirstOrDefault().Z_Position_Start - SelectProduct.ScrewPoints.FirstOrDefault().Z_Position_Stop) : 0;
                LockXSpeed = SelectProduct.ScrewPoints.FirstOrDefault()?.X_Velocity ?? 100;
                LockYSpeed = SelectProduct.ScrewPoints.FirstOrDefault()?.Y_Velocity ?? 100;
                LockZSpeed = SelectProduct.ScrewPoints.FirstOrDefault()?.Z_Velocity_Start ?? 100;
                LockZDescendSpeed = SelectProduct.ScrewPoints.FirstOrDefault()?.Z_Velocity_Stop ?? 100;
                LockFeederNumber = SelectProduct.ScrewPoints.FirstOrDefault()?.Feeder ?? 1;
                LockScrewProgramNumber = SelectProduct.ScrewPoints.FirstOrDefault()?.ScrewProNum ?? 1;

                CameraList = new ObservableCollection<CameraInfo>(_configService.GetAllCameras());
               
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.机器人点位界面进入时出错, ex);
            }
        }

        /// <summary>
        /// 是否允许导航到此视图模型。
        /// </summary>
        /// <param name="navigationContext"></param>
        /// <returns></returns>
        public bool IsNavigationTarget(NavigationContext navigationContext)
        {
            return true;
        }

        /// <summary>
        /// 导航离开此视图模型时调用。您可以在此处执行清理操作或保存状态。
        /// </summary>
        /// <param name="navigationContext"></param>
        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
            //if (Robot != null)
            //{
            //    Robot.EnterDebugMode = false;
            //}
            try
            {
                IsGrap = false;
                if (Camera != null)
                {
                    if (Camera.IsGrabbing)
                    {
                        Camera.StopGrabbing();
                    }
                    Camera.ImageCallbackEvent -= Camera_ImageCallbackEvent;
                    
                    Camera = null;
                }
                SelectedCamera = null;
                IsLeftDrawerOpen = false;
            }
            catch (Exception)
            {

            }
        }
        #endregion

        #region 取料拍照点位矫正
        private PlcPoint _SelectedCameraForPickPoint;
        public PlcPoint SelectedCameraForPickPoint
        {
            get { return _SelectedCameraForPickPoint; }
            set { SetProperty(ref _SelectedCameraForPickPoint, value); }
        }


        private ObservableCollection<PlcPoint> _PickPoints = new ObservableCollection<PlcPoint>();
        /// <summary>
        /// 取料点位集合
        /// </summary>
        public ObservableCollection<PlcPoint> PickPoints
        {
            get { return _PickPoints; }
            set { SetProperty(ref _PickPoints, value); }
        }

        //
        private PlcPoint _SelectedPickPoint;
        /// <summary>
        /// 选中的取料点位
        /// </summary>
        public PlcPoint SelectedPickPoint
        {
            get { return _SelectedPickPoint; }
            set { SetProperty(ref _SelectedPickPoint, value); }
        }

        private DelegateCommand _AutoCorrectPickPointCommand;
        public DelegateCommand AutoCorrectPickPointCommand =>
            _AutoCorrectPickPointCommand ?? (_AutoCorrectPickPointCommand = new DelegateCommand(ExecuteAutoCorrectPickPointCommand, CanExecuteAutoCorrectPickPointCommand)
            .ObservesProperty(() => SelectedCameraForPickPoint).ObservesProperty(() => SelectedPickPoint).ObservesProperty(() => SelectProcedure).ObservesProperty(() => IsExecutingAutoCorrectPickPoint));

        //
        private bool _IsExecutingAutoCorrectPickPoint = false;
        /// <summary>
        /// 正在执行取料拍照点位矫正
        /// </summary>
        public bool IsExecutingAutoCorrectPickPoint
        {
            get { return _IsExecutingAutoCorrectPickPoint; }
            set { SetProperty(ref _IsExecutingAutoCorrectPickPoint, value); }
        }

        async void ExecuteAutoCorrectPickPointCommand()
        {
            try
            {
                IsExecutingAutoCorrectPickPoint = true;
                if (SelectedCameraForPickPoint == null || SelectedPickPoint == null || SelectProcedure == null)
                {
                    return;
                }
                if (Robot == null || !Robot.IsConnected)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.机器人未连接无法执行取料拍照点位矫正, Duration = 1 });
                    return;
                }
                if (MessageBox.Show(Lang.确认要执行取料拍照点位矫正吗, Lang.取料拍照点位矫正, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                {
                    return;
                }

                var waiting = new WaitingControl();
                //show the dialog
                var task = DialogHost.Show(waiting, "RootDialog", null, null, null);

                // 1. 控制机器人移动至拍照点位
                var rpoint = new RPoint()
                {
                    X = SelectedCameraForPickPoint.X_Position,
                    Y = SelectedCameraForPickPoint.Y_Position,
                    Z = SelectedCameraForPickPoint.Z_Position_Start,
                    U = SelectedCameraForPickPoint.U_Position,
                    V = SelectedCameraForPickPoint.R_Position,
                };
                await Robot.CalibMotionAsync(rpoint, 0);

                var _cts = new CancellationTokenSource();
                // 2. 执行拍照并获取识别结果
                var recognitionResult = await _remoteCommandService.ExecutePhotoGetSinglePointWithImage(SelectProcedure, null, new double[] { rpoint.X, rpoint.Y, 0 }, _cts.Token);
                if (!recognitionResult.IsSucceed)
                {
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.取料拍照点位矫正失败识别未成功, Duration = 1 });
                    return;
                }

                // 3. 根据识别结果更新取料点位坐标
                SelectedPickPoint.X_Position = (float)recognitionResult.X;
                SelectedPickPoint.Y_Position = (float)recognitionResult.Y;

                if (DialogHost.IsDialogOpen("RootDialog"))
                {
                    DialogHost.Close("RootDialog");
                }
                await task;

                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.取料拍照点位矫正完成, Duration = 0.4 });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError(Lang.取料拍照点位矫正时出错, ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
            finally
            {
                IsExecutingAutoCorrectPickPoint = false;
            }
        }

        bool CanExecuteAutoCorrectPickPointCommand()
        {
            return SelectedCameraForPickPoint != null && SelectedPickPoint != null && SelectProcedure != null && !IsExecutingAutoCorrectPickPoint;
        }

        #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;
            }
        }
    }
}