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.Core.Robots;
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 ObservableCollection<AxisExtended> _AdditionalAxisList;
        public ObservableCollection<AxisExtended> AdditionalAxisList
        {
            get { return _AdditionalAxisList; }
            set { SetProperty(ref _AdditionalAxisList, value); }
        }

        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 XYZU_Robot _Robot;

        public XYZU_Robot 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<object> _AdditionalAxisJogPlusCommand;
        public DelegateCommand<object> AdditionalAxisJogPlusCommand =>
            _AdditionalAxisJogPlusCommand ?? (_AdditionalAxisJogPlusCommand = new DelegateCommand<object>(ExecuteAdditionalAxisJogPlusCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        //附加轴,轴点动-命令
        private DelegateCommand<object> _AdditionalAxisJogMinusCommand;
        public DelegateCommand<object> AdditionalAxisJogMinusCommand =>
            _AdditionalAxisJogMinusCommand ?? (_AdditionalAxisJogMinusCommand = new DelegateCommand<object>(ExecuteAdditionalAxisJogMinusCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        private DelegateCommand<object> _AdditionalAxisMotorOnCommand;
        public DelegateCommand<object> AdditionalAxisMotorOnCommand =>
            _AdditionalAxisMotorOnCommand ?? (_AdditionalAxisMotorOnCommand = new DelegateCommand<object>(ExecuteAdditionalAxisMotorOnCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        private DelegateCommand<object> _AdditionalAxisMotorOffCommand;
        public DelegateCommand<object> AdditionalAxisMotorOffCommand =>
            _AdditionalAxisMotorOffCommand ?? (_AdditionalAxisMotorOffCommand = new DelegateCommand<object>(ExecuteAdditionalAxisMotorOffCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        #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($"确认要点动距离 {distance} mm 吗？", "确认点动", 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("机器人点位-机器人点动时出错", 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($"确认要执行点位 {SelectedPoint.Number} 的 {motionCmd} 指令吗？", "执行点位", 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("机器人点位-执行点位时出错", 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 = "当前模式不允许直接示教锁付点位，请先通过相机定位产品！", Duration = 1 });
                        return;
                    }

                    //弹窗用户是否确认要示教该点位
                    if (MessageBox.Show($"确认要示教点位 {SelectedPoint.Number} 吗？", "示教点位", 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($"确认要示教点位 {SelectedPoint.Number} 吗？", "示教点位", 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("机器人点位-示教点位时出错", 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("机器人点击操作时出错！", 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("重置机器人时出错！", 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("机器人锁定刹车时出错！", 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("机器人释放刹车时出错！", 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("确认要删除选中的点位吗？", "删除点位", 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("确认将选中点位上移一位吗？", "移动点位", 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("确认将选中点位下移一位吗？", "移动点位", 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($"确认要从点位编号 {startNumber} 开始导入 {cadPoints.Count} 个点位吗？", "导入点位", 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("导入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($"确认要导入锁付拍照引导的起始点和结束点吗？", "导入点位", 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 = "请导入两个点，分别为锁付拍照引导的起始点和结束点！", Duration = 1 });
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("导入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("供料器编号或螺丝程序编号小于等于0，是否继续写入？", "确认", 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("速度小于等于0，是否继续写入？", "确认", 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("深度小于等于0，是否继续写入？", "确认", 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("起始Z坐标大于等于0，是否继续写入？", "确认", 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($"点位编号 {point.Number} 的终点坐标大于等于起始坐标，请调整终点坐标！", "警告", MessageBoxButton.OK, MessageBoxImage.Warning);
                }
            }

        }

        /// <summary>
        /// 通过相机自动矫正锁附点位
        /// </summary>
        async void ExecuteAutoCorrectLockPoint()
        {
            try
            {
                if (Camera != null)
                {
                    if (Camera.IsGrabbing)
                    {
                        ExecuteStopGrabbingCommand();
                    }
                }
                //弹窗提示用户是否确认要通过相机自动矫正锁附点位
                var resultConfirm = MessageBox.Show("确认要通过相机自动矫正锁附点位吗？", "确认", 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("锁付点位中有和锁付拍照引导起始点Local坐标相同的点位，且Z坐标不一致，是否将锁付拍照引导起始点Local坐标的Z轴坐标更新为锁付点位的Z坐标？", "确认", 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("锁付点位中有和锁付拍照引导结束点Local坐标相同的点位，且Z坐标不一致，是否将锁付拍照引导结束点Local坐标的Z轴坐标更新为锁付点位的Z坐标？", "确认", 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 = "完成！", Duration = 1 });
                    }

                });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("通过相机自动矫正锁附点位时出错！", 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($"确认要通过相机自动矫正锁附点位并执行点位 {point.Number} 吗？", "确认", MessageBoxButton.YesNo, MessageBoxImage.Question);
                if (resultConfirm != MessageBoxResult.Yes)
                {
                    return;
                }


                if (Robot == null || !Robot.IsConnected)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = "机器人未连接，无法执行取料拍照点位矫正！", Duration = 1 });
                    return;
                }
                //获取当前产品
                var product = SelectProduct;
                if (product == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = "未选择产品，无法执行取料拍照点位矫正！", 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("系统检测到进入此界面后已经进行过相机产品定位并计算过Local，是否继续使用该Local进行锁付点位的转换计算？点击“是”继续使用，点击“否”则重新进行锁付点位的Local计算。", "确认", 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 = "完成！", Duration = 1 });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("通过相机自动矫正锁附点位并执行时出错！", 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 = "未获取到锁付相机拍照点位，无法执行取料拍照点位矫正！", Duration = 1 });
                    return false;
                }
                //获取相机拍照点位对应的锁付点
                var screwCameraLocalPoint1 = product.ScrewCameraLocalPos1;
                if (screwCameraLocalPoint1 == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = "未获取到锁付相机拍照点位对应的锁付点，无法执行取料拍照点位矫正！", Duration = 1 });
                    return false;
                }
                var screwCameraLocalPoint2 = product.ScrewCameraLocalPos2;
                if (screwCameraLocalPoint2 == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = "未获取到锁付相机拍照点位对应的锁付点，无法执行取料拍照点位矫正！", 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 = "未获取到锁付相机拍照流程，无法执行取料拍照点位矫正！", Duration = 1 });
                    return false;
                }
                var procedure = ProcedureModels.FirstOrDefault(p => p.Id == product.MoveDownCameraLockPhotoProcedureId);
                if (procedure == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = "未获取到锁付相机拍照流程，无法执行取料拍照点位矫正！", 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 = "拍照获取识别结果失败，无法执行取料拍照点位矫正！", 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 = "拍照获取识别结果失败，无法执行取料拍照点位矫正！", 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("计算锁付点位产品坐标系坐标时出错！", ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
                return false;
            }
        }

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

        /// <summary>
        /// 附加轴+点动
        /// </summary>
        /// <param name="obj"></param>
        async void ExecuteAdditionalAxisJogPlusCommand(object obj)
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                if (obj is AxisExtended axis)
                {
                    //如果移动距离大于10mm，则提示用户确认
                    if (Math.Abs(Distance) >= 10)
                    {
                        if (MessageBox.Show($"确认要点动距离 {Distance} mm 吗？", "确认点动", MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                        {
                            return;
                        }
                    }
                    await Robot.AdditionalAxisJogAsync(axis.Name, Distance);
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("附加轴点动+时出错！", ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg =ex.Message, Duration = 0.4 });
            }
        }

        /// <summary>
        /// 附加轴-点动
        /// </summary>
        /// <param name="obj"></param>
        async void ExecuteAdditionalAxisJogMinusCommand(object obj)
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                if (obj is AxisExtended axis)
                {
                    //如果移动距离大于10mm，则提示用户确认
                    if (Math.Abs(Distance) >= 10)
                    {
                        if (MessageBox.Show($"确认要点动距离 {Distance} mm 吗？", "确认点动", MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                        {
                            return;
                        }
                    }
                    await Robot.AdditionalAxisJogNegAsync(axis.Name, Distance);
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("附加轴点动-时出错！", ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 0.4 });
            }
        }

        /// <summary>
        /// 附加轴上使能
        /// </summary>
        /// <param name="obj"></param>
        async void ExecuteAdditionalAxisMotorOffCommand(object obj)
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                if (obj is AxisExtended axis)
                {
                    await Robot.AdditionalAxisMotorAsync(axis.Name, true);
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("附加轴上使能时出错！", ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 0.4 });
            }
        }

        /// <summary>
        /// 附加轴下使能
        /// </summary>
        /// <param name="obj"></param>
        async void ExecuteAdditionalAxisMotorOnCommand(object obj)
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                if (obj is AxisExtended axis)
                {
                    await Robot.AdditionalAxisMotorAsync(axis.Name, true);
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("附加轴下使能时出错！", ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 0.4 });
            }
        }
        #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) as XYZU_Robot;
                }

                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("机器人点位界面进入时出错！", 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 = "机器人未连接，无法执行取料拍照点位矫正！", Duration = 1 });
                    return;
                }
                if (MessageBox.Show("确认要执行取料拍照点位矫正吗？", "取料拍照点位矫正", 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.ExecutePhotoGetSinglePoint(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 = "取料拍照点位矫正失败，识别未成功！", 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 = "取料拍照点位矫正完成！", Duration = 0.4 });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("取料拍照点位矫正时出错！", 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;
            }
        }
    }
}