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

using Cognex.VisionPro;
using MahApps.Metro.Controls;
using MaterialDesignThemes.Wpf;
using MathNet.Numerics;
using MathNet.Numerics.LinearAlgebra;
using Microsoft.Win32;
using NPOI.SS.Formula.Functions;
using OpenCvSharp.Flann;
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.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Xml.Serialization;
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;
        IProductService _productService;

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

        private int _Inhal = 1;
        public int Inhal
        {
            get { return _Inhal; }
            set { SetProperty(ref _Inhal, value); }
        }

        private PlcPoint _PickP1 = new PlcPoint();
        public PlcPoint PickP1
        {
            get { return _PickP1; }
            set { SetProperty(ref _PickP1, value); }
        }

        private PlcPoint _PickP2 = new PlcPoint();
        public PlcPoint PickP2
        {
            get { return _PickP2; }
            set { SetProperty(ref _PickP2, value); }
        }

        private int _ColumnNum = 18;
        public int ColumnNum
        {
            get { return _ColumnNum; }
            set { SetProperty(ref _ColumnNum, value); }
        }

        #endregion

        #region DTOs for import/export
        public class ProductPointsExport
        {
            /// <summary>
            /// 软件版本号
            /// </summary>
            public string SoftwareVersion { get; set; }

            /// <summary>
            /// 产品名称
            /// </summary>
            public string ProductName { get; set; }

            /// <summary>
            /// 产品描述
            /// </summary>
            public string ProductDescription { get; set; }

            /// <summary>
            /// 设备名称
            /// </summary>
            public string DeviceName { get; set; }

            /// <summary>
            /// 创建日期
            /// </summary>
            public DateTime? Created { get; set; }

            public List<PlcPoint> PickCameraPoints { get; set; }
            public List<PlcPoint> PickPoints { get; set; }
            public List<PlcPoint> SecPosCameraPoints { get; set; }
            public List<PlcPoint> ScrewCameraPoints { get; set; }
            public PlcPoint ScrewCameraLocalPos1 { get; set; }
            public PlcPoint ScrewCameraLocalPos2 { get; set; }
            public List<PlcPoint> ScrewPoints { get; set; }
            public List<PlcPoint> CheckCameraPoints { get; set; }
            public List<PlcPoint> RemovePoints { get; set; }
            public List<PlcPoint> PressurePlacePoints { get; set; }
            public List<PlcPoint> CameraCodePlcPoints { get; set; }
            public List<PlcPoint> GunPressurePoints { get; set; }
            public List<PlcPoint> ProductPlacePoints { get; set; }
        }
        #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 _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 _GoPickCommand;
        public DelegateCommand GoPickCommand =>
            _GoPickCommand ?? (_GoPickCommand = new DelegateCommand(ExecuteGoPickCommand, CanExecuteCommandGoPickCommandName).ObservesProperty(() => SelectedPoint));

        private DelegateCommand _GoRepositionCommand;
        public DelegateCommand GoRepositionCommand =>
            _GoRepositionCommand ?? (_GoRepositionCommand = new DelegateCommand(ExecuteGoRepositionCommand, CanExecuteCommandGoPickCommandName).ObservesProperty(() => SelectedPoint));

        private DelegateCommand _TakeProductPhotoCommand;
        public DelegateCommand TakeProductPhotoCommand =>
            _TakeProductPhotoCommand ?? (_TakeProductPhotoCommand = new DelegateCommand(ExecuteTakeProductPhotoCommand, CanExecuteCommandGoPickCommandName).ObservesProperty(() => SelectedPoint));

        private DelegateCommand _TakeProductCommand;
        public DelegateCommand TakeProductCommand =>
            _TakeProductCommand ?? (_TakeProductCommand = new DelegateCommand(ExecuteTakeProductCommand, CanExecuteCommandGoPickCommandName).ObservesProperty(() => SelectedPoint));

        //附加轴,轴点动+命令
        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));

        private DelegateCommand<string> _PickTechCommand;
        public DelegateCommand<string> PickTechCommand =>
            _PickTechCommand ?? (_PickTechCommand = new DelegateCommand<string>(ExecutePickTechCommand));

        private DelegateCommand<string> _PickMoveCommand;
        public DelegateCommand<string> PickMoveCommand =>
            _PickMoveCommand ?? (_PickMoveCommand = new DelegateCommand<string>(ExecutePickMoveCommand));

        private DelegateCommand _CalPickPosCommand;
        public DelegateCommand CalPickPosCommand =>
            _CalPickPosCommand ?? (_CalPickPosCommand = new DelegateCommand(ExecuteCalPickPosCommand));

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

        private DelegateCommand _SetOffsetCommand;
        public DelegateCommand SetOffsetCommand =>
            _SetOffsetCommand ?? (_SetOffsetCommand = new DelegateCommand(ExecuteSetOffsetCommand));

        private DelegateCommand _ImportPointsCommand;
        public DelegateCommand ImportPointsCommand =>
            _ImportPointsCommand ?? (_ImportPointsCommand = new DelegateCommand(ExecuteImportPointsCommand));

        private DelegateCommand _ExportAllPointsCommand;
        public DelegateCommand ExportAllPointsCommand =>
            _ExportAllPointsCommand ?? (_ExportAllPointsCommand = new DelegateCommand(ExecuteExportAllPointsCommand));
        #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, IProductService productService)
        {
            _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;
            _productService = productService;
        }

        #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("机器人点位-机器人点动时出错", 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 (MessageBox.Show(string.Format(Lang.确认要执行点位0的1指令吗,SelectedPoint.Number,motionCmd), Lang.执行点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                {
                    return;
                }

                //if (SelectedIndex == 7)//产品升降取料位（附加轴1，2）
                //{
                //    //await Robot.AdditionalAxisMoveAsync(Robot.AdditionalAxisList[0].Name, SelectedPoint.Z_Position_Start);//取料升降Z轴
                //    await Robot.AdditionalAxisMoveAsync(Robot.AdditionalAxisList[1].Name, SelectedPoint.Y_Position);//取料移栽Y轴

                //}

                if (SelectedIndex == 8)//产品升降取料位（附加轴1，2）//plc说上位机控会有撞机问题，直接不控
                {
                    //await Robot.AdditionalAxisMoveAsync(Robot.AdditionalAxisList[0].Name, SelectedPoint.Z_Position_Start);//取料升降Z轴
                    //await Robot.AdditionalAxisMoveAsync(Robot.AdditionalAxisList[1].Name, SelectedPoint.Y_Position);//取料移栽Y轴

                }
                else if(SelectedIndex == 9)//滚压点位（X,Y和附加轴3）
                {
                    var curpos1 = await Robot.GetRobotPosAsync();
                    float safeZ= _configService.GetSystemConfiguration().GunyaSafeZ;
                    //double safeZ = Robot.SafeZ;
                    await Robot.AdditionalAxisMoveAsync(Robot.AdditionalAxisList[2].Name, safeZ);//滚压Z轴
                    point.Z = curpos1.Z;//其它轴运动到当前位置
                    point.U = curpos1.W;
                    point.V = curpos1.V;
                    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;
                    }

                    await Robot.AdditionalAxisMoveAsync(Robot.AdditionalAxisList[2].Name, SelectedPoint.Z_Position_Start);//滚压Z轴
                }
                else
                {
                    //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;
                    }
                }

                _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 (toolCoord == null)
                    {
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = "当前模式不允许直接示教贴敷点位，请先通过相机定位产品和定位辅料！", Duration = 1 });
                        return;
                    }

                    //弹窗用户是否确认要示教该点位
                    if (MessageBox.Show(string.Format(Lang.确认要示教点位0吗, SelectedPoint.Number), Lang.示教点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                    {
                        return;
                    }
                    double upCameraU = Common.CalculateAngleBetweenPointsDegrees(new PointF((float)_PutPoints[0].X, (float)_PutPoints[0].Y), new PointF((float)_PutPoints[1].X, (float)_PutPoints[1].Y));

                    var curpos1 = await Robot.GetRobotPosAsync();
                    //将当前点位转换为产品Local坐标系下的点位
                    SelectedPoint.X_Position = (float)curpos1.X;
                    SelectedPoint.Y_Position = (float)curpos1.Y;
                    SelectedPoint.Z_Position_Start = curpos1.Z;
                    SelectedPoint.U_Position = curpos1.U;
                    SelectedPoint.R_Position = curpos1.V;
                    SelectProduct.FixedUpCameraTempletAngle = _FixedUpCameraTempletAngle;
                    SelectProduct.MoveDownCamerTempletAngle = upCameraU;
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                    return;
                }
                else if (SelectedIndex == 7)
                {
                    //弹窗用户是否确认要示教该点位
                    if (MessageBox.Show(string.Format(Lang.确认要示教点位0吗, SelectedPoint.Number), Lang.示教点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                    {
                        return;
                    }
                    var curpos = await Robot.GetRobotPosAsync();
                    //var Z = await Robot.GetAdditionalAxisCurrentPosAsync(Robot.AdditionalAxisList[0].Name);//附加取料升降Z轴
                    var Y = await Robot.GetAdditionalAxisCurrentPosAsync(Robot.AdditionalAxisList[1].Name);//附加移栽Y轴
                    SelectedPoint.X_Position = curpos.X;
                    SelectedPoint.Y_Position = Y;
                    SelectedPoint.Z_Position_Start = curpos.Z;
                    //SelectedPoint.U_Position = 0;
                    //SelectedPoint.R_Position = 0;
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                    return;
                }
                else if(SelectedIndex == 8)
                {
                    //弹窗用户是否确认要示教该点位
                    if (MessageBox.Show(string.Format(Lang.确认要示教点位0吗, SelectedPoint.Number), Lang.示教点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                    {
                        return;
                    }
                    var Z = await Robot.GetAdditionalAxisCurrentPosAsync(Robot.AdditionalAxisList[0].Name);//附加取料升降Z轴
                    var Y= await Robot.GetAdditionalAxisCurrentPosAsync(Robot.AdditionalAxisList[1].Name);//附加移栽Y轴
                    SelectedPoint.X_Position = 0;
                    SelectedPoint.Y_Position = Y;
                    SelectedPoint.Z_Position_Start = Z;
                    //SelectedPoint.U_Position = 0;
                    //SelectedPoint.R_Position = 0;
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}!", Duration = 0.4 });
                    return;
                }
                else if (SelectedIndex == 9)
                {
                    //弹窗用户是否确认要示教该点位
                    if (MessageBox.Show(string.Format(Lang.确认要示教点位0吗, SelectedPoint.Number), Lang.示教点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                    {
                        return;
                    }
                    var curpos = await Robot.GetRobotPosAsync();
                    var Z = await Robot.GetAdditionalAxisCurrentPosAsync(Robot.AdditionalAxisList[2].Name);//滚压升降Z轴
                    SelectedPoint.X_Position = curpos.X;
                    SelectedPoint.Y_Position = curpos.Y;
                    SelectedPoint.Z_Position_Start = Z;
                    //SelectedPoint.U_Position = 0;
                    //SelectedPoint.R_Position = 0;
                    _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("机器人点位-示教点位时出错", 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;
                    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;
                case 6:
                    Points = SelectProduct.RemovePoints;
                    break;
                case 7:
                    Points = SelectProduct.CameraCodePlcPoints;
                    break;
                case 8:
                    Points = SelectProduct.ProductPlacePoints;
                    break;
                case 9:
                    Points = SelectProduct.GunPressurePoints;
                    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("导入CAD点位时出错！", ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }


        /// <summary>
        /// 设置偏移
        /// </summary>
        void ExecuteSetOffsetCommand()
        {
            if (SelectedIndex < 0) return;
            IDialogParameters parameters1 = new DialogParameters();
            if (SelectedIndex == 0)
            {
                parameters1.Add("Title", Lang.取料拍照点位补偿值设置);
            }
            else if (SelectedIndex == 1)
            {
                parameters1.Add("Title", Lang.取料点位补偿值设置);
            }
            else if (SelectedIndex == 2)
            {
                parameters1.Add("Title", Lang.下相机二次定位点位补偿值设置);
            }
            else if (SelectedIndex == 3)
            {
                parameters1.Add("Title", Lang.锁附拍照点位补偿值设置);
            }
            else if (SelectedIndex == 4)
            {
                parameters1.Add("Title", Lang.锁附点位补偿值设置);
            }
            else if (SelectedIndex == 5)
            {
                parameters1.Add("Title", Lang.复检点位补偿值设置);
            }
            else
            {
                parameters1.Add("Title", Lang.点位补偿值设置);
            }

            List<PlcPoint> _points = new List<PlcPoint>();
            foreach (var item in Points)
            {
                _points.Add(item.Clone());
            }
            parameters1.Add("Points", _points.ToArray());
            _dialogService.ShowDialog("PlcPointOffserParams", parameters1, rst =>
            {
                //对话框关闭之后的回调函数，可以在这解析结果。
                ButtonResult result1 = rst.Result;

                if (result1 == ButtonResult.OK)
                {
                    var param = rst.Parameters.GetValue<PlcPoint[]>("Points");

                    //更新点位
                    for (int i = 0; i < Points.Count; i++)
                    {
                        Points[i].X_Offset = param[i].X_Offset;
                        Points[i].Y_Offset = param[i].Y_Offset;
                        Points[i].Z_Start_Offset = param[i].Z_Start_Offset;
                        Points[i].Z_Stop_Offset = param[i].Z_Stop_Offset;
                        Points[i].U_Offset = param[i].U_Offset;
                        Points[i].R_Offset = param[i].R_Offset;
                    }

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

            });
        }

        /// <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>
        async void ExecuteGoPickCommand()
        {
            try
            {
                if (SelectedPoint == null)
                {
                    return;
                }
                if (Robot == null || !Robot.IsConnected)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = "机器人未连接，无法执行取料！", 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 = SelectedPoint.X_Position,
                    Y = SelectedPoint.Y_Position,
                    Z = SelectedPoint.Z_Position_Start,
                    U = SelectedPoint.U_Position,
                    V = SelectedPoint.R_Position,
                };
                await Robot.CalibMotionAsync(rpoint, 0);

                await Robot.CalibParameAsync(new PickInfo() { Inhal = Inhal, Blow = 1 }, 20, 20, true, 200, 200);
                //打开吸真空
                await Robot.CalibOutIOAsync(true);

                await Task.Delay(500);

                rpoint.Z = 0;
                await Robot.CalibMotionAsync(rpoint, 0);

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

        bool CanExecuteCommandGoPickCommandName()
        {
            return SelectedPoint != null;
        }

        ToolCoord toolCoord = null;
        double _FixedUpCameraTempletAngle = 0;
        OpenCvSharp.Point3f[] _PutPoints = new OpenCvSharp.Point3f[2];
        /// <summary>
        /// 去二次定位
        /// </summary>
        async void ExecuteGoRepositionCommand()
        {
            try
            {
                if (SelectedPoint == 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 = SelectedPoint.X_Position,
                    Y = SelectedPoint.Y_Position,
                    Z = SelectedPoint.Z_Position_Start,
                    U = SelectedPoint.U_Position,
                    V = SelectedPoint.R_Position,
                };
                await Robot.CalibMotionAsync(rpoint, 0);
                await Task.Delay(200);

                //获取固定向上相机1的流程
                var process1 = _productService.GetCurrentProductProcedureModelById(SelectProduct.FixedUpCamera1ProcedureId);
                if (process1 == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"固定向上相机1视觉流程，流程ID：{SelectProduct.FixedUpCamera1ProcedureId} 未找到！", Duration = 1 });
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    return;
                }
                //获取固定向上相机2的流程
                var process2 = _productService.GetCurrentProductProcedureModelById(SelectProduct.FixedUpCamera2ProcedureId);
                if (process2 == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"固定向上相机2视觉流程，流程ID：{SelectProduct.FixedUpCamera2ProcedureId} 未找到！", Duration = 1 });
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    return;
                }
                // 执行视觉任务
                var _cts = new CancellationTokenSource();
                var task1 = _remoteCommandService.ExecutePhotoGetSinglePointWithImage(process1, null, new double[] { rpoint.X, rpoint.Y, rpoint.U }, _cts.Token);
                var task2 = _remoteCommandService.ExecutePhotoGetSinglePointWithImage(process2, null, new double[] { rpoint.X, rpoint.Y, rpoint.U }, _cts.Token);
                var visionResults = await Task.WhenAll(task1, task2);
                if (visionResults[0].IsSucceed && visionResults[1].IsSucceed)
                {
                    float toolX = (float)(visionResults[0].X + visionResults[1].X) / 2;
                    float toolY = (float)(visionResults[0].Y + visionResults[1].Y) / 2;
                    _FixedUpCameraTempletAngle = Common.CalculateAngleBetweenPointsDegrees(new PointF((float)visionResults[0].X, (float)visionResults[0].Y), new PointF((float)visionResults[1].X, (float)visionResults[1].Y));
                    toolCoord = new ToolCoord();
                    toolCoord.SetTool(toolX, toolY);
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.视觉定位成功, Duration = 0.4 });
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    return;
                }
                else
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.视觉定位失败无法进行二次定位, Duration = 1 });
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    return;
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("二次定位时出错！", ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
                if (DialogHost.IsDialogOpen("RootDialog"))
                {
                    DialogHost.Close("RootDialog");
                }
            }
        }

        /// <summary>
        /// 执行产品拍照
        /// </summary>
        async void ExecuteTakeProductPhotoCommand()
        {
            try
            {
                if (SelectedPoint == 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;
                }

                //如果二次定位的工具坐标为空，则提示用户先进行二次定位
                if (toolCoord == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.二次定位的工具坐标为空无法执行产品拍照, Duration = 1 });
                    return;
                }

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

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

                //获取移动向下相机1的流程
                var process1 = _productService.GetCurrentProductProcedureModelById(Points[0].VisionProcessID);
                if (process1 == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = string.Format(Lang.移动向下相机1视觉流程流程ID0未找到,Points[0].VisionProcessID), Duration = 1 });
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    return;
                }
                // 执行视觉任务
                var _cts = new CancellationTokenSource();
                var visionResult =await _remoteCommandService.ExecutePhotoGetSinglePointWithImage(process1, null, new double[] { rpoint.X, rpoint.Y, rpoint.U }, _cts.Token);
                if (visionResult.IsSucceed)
                {
                    _PutPoints[0] = new OpenCvSharp.Point3f((float)visionResult.X, (float)visionResult.Y, (float)visionResult.U);
                }
                else
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.视觉定位失败无法进行产品拍照, Duration = 1 });
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    return;
                }

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

                //获取移动向下相机1的流程
                var process2= _productService.GetCurrentProductProcedureModelById(Points[1].VisionProcessID);
                if (process2 == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = string.Format(Lang.移动向下相机2视觉流程流程ID0未找到, Points[1].VisionProcessID), Duration = 1 });
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    return;
                }
                // 执行视觉任务
                _cts = new CancellationTokenSource();
                visionResult = await _remoteCommandService.ExecutePhotoGetSinglePointWithImage(process2, null, new double[] { rpoint.X, rpoint.Y, rpoint.U }, _cts.Token);
                if (visionResult.IsSucceed)
                {
                    _PutPoints[1] = new OpenCvSharp.Point3f((float)visionResult.X, (float)visionResult.Y, (float)visionResult.U);

                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    return;
                }
                else
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.视觉定位失败无法进行产品拍照, Duration = 1 });
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    return;
                }

            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("执行产品拍照时出错！", ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
                if (DialogHost.IsDialogOpen("RootDialog"))
                {
                    DialogHost.Close("RootDialog");
                }
            }
        }

        /// <summary>
        /// 执行产品贴敷
        /// </summary>
        async void ExecuteTakeProductCommand()
        {
            try
            {
                if (SelectedPoint == 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;
                }

                //如果二次定位的工具坐标为空，则提示用户先进行二次定位
                if (toolCoord == null)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.二次定位的工具坐标为空无法执行产品拍照, Duration = 1 });
                    return;
                }

                if (_PutPoints[0].X == 0 && _PutPoints[0].Y == 0 && _PutPoints[1].X == 0 && _PutPoints[1].Y == 0)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.检测到未定位产品, Duration = 1 });
                    return;
                }

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

                double upCameraX = (_PutPoints[0].X + _PutPoints[1].X) / 2;
                double upCameraY = (_PutPoints[0].Y + _PutPoints[1].Y) / 2;
                double upCameraU = Common.CalculateAngleBetweenPointsDegrees(new PointF((float)_PutPoints[0].X, (float)_PutPoints[0].Y), new PointF((float)_PutPoints[1].X, (float)_PutPoints[1].Y));

                var pn = Vector<double>.Build.Dense(new double[] { upCameraX, upCameraY });
                //目标角度：
                double angle = SelectedPoint.U_Position + (_FixedUpCameraTempletAngle - SelectProduct.FixedUpCameraTempletAngle) + (upCameraU - SelectProduct.MoveDownCamerTempletAngle);
                //将_PutPoint转换为Tool0下要走的点
                var p0 = toolCoord.GetTool0Coord(pn, angle);

                // 1. 控制机器人移动至拍照点位
                var rpoint = new RPoint()
                {
                    X = (float)p0[0],
                    Y = (float)p0[1],
                    Z = SelectedPoint.Z_Position_Start,
                    U = (float)angle,
                    V = SelectedPoint.R_Position,
                };
                await Robot.CalibMotionAsync(rpoint, 0);
                if (DialogHost.IsDialogOpen("RootDialog"))
                {
                    DialogHost.Close("RootDialog");
                }
                await task;
                return;

            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("执行产品贴敷时出错！", ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
                if (DialogHost.IsDialogOpen("RootDialog"))
                {
                    DialogHost.Close("RootDialog");
                }
            }
        }

        /// <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(string.Format(Lang.确认要点动距离0mm吗, Distance), Lang.确认点动, 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 = 1 });
            }
        }

        /// <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(string.Format(Lang.确认要点动距离0mm吗, Distance), Lang.确认点动, 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 = 1 });
            }
        }

        /// <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, false);
                    _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 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 = 1 });
            }
        }

        /// <summary>
        /// 移动取料托盘点
        /// </summary>
        async void ExecutePickMoveCommand(string parameter)
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                //弹窗用户是否确认要示教该点位
                if (MessageBox.Show(string.Format(Lang.确认要移动取料点位0吗, parameter), Lang.移动点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                {
                    return;
                }
                int index = int.Parse(parameter);
                var curpos = await Robot.GetRobotPosAsync();
                var addpos = await Robot.GetAdditionalAxisCurrentPosAsync(Robot.AdditionalAxisList[0].Name);
                if (index == 1)
                {
                    curpos.Z = 0;
                    await Robot.CalibMotionAsync(curpos, 0);

                    await Robot.AdditionalAxisMoveAsync(Robot.AdditionalAxisList[0].Name, PickP1.Z_Position_Stop);
                    curpos.X = PickP1.X_Position;
                    curpos.Y = PickP1.Y_Position;
                    curpos.Z = PickP1.Z_Position_Start;
                    curpos.U = PickP1.U_Position;
                    await Robot.CalibMotionAsync(curpos, 0);
                }
                else if (index == 2)
                {
                    curpos.Z = 0;
                    await Robot.CalibMotionAsync(curpos, 0);

                    await Robot.AdditionalAxisMoveAsync(Robot.AdditionalAxisList[0].Name, PickP2.Z_Position_Stop);
                    curpos.X = PickP2.X_Position;
                    curpos.Y = PickP2.Y_Position;
                    curpos.Z = PickP2.Z_Position_Start;
                    curpos.U = PickP2.U_Position;
                    await Robot.CalibMotionAsync(curpos, 0);
                }
                _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="parameter"></param>
        async void ExecutePickTechCommand(string parameter)
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                //弹窗用户是否确认要示教该点位
                if (MessageBox.Show(string.Format(Lang.确认要示教取料点位0吗, parameter), Lang.示教点位, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                {
                    return;
                }

                int index = int.Parse(parameter);
                var curpos = await Robot.GetRobotPosAsync();
                var addpos = await Robot.GetAdditionalAxisCurrentPosAsync(Robot.AdditionalAxisList[0].Name);
                if (index == 1)
                {
                    PickP1.X_Position = curpos.X;
                    PickP1.Y_Position = curpos.Y;
                    PickP1.Z_Position_Start = curpos.Z;
                    PickP1.U_Position = curpos.U;
                    PickP1.Z_Position_Stop = addpos;
                }
                else if (index == 2)
                {
                    PickP2.X_Position = curpos.X;
                    PickP2.Y_Position = curpos.Y;
                    PickP2.Z_Position_Start = curpos.Z;
                    PickP2.U_Position = curpos.U;
                    PickP2.Z_Position_Stop = addpos;
                }
                _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>
        void ExecuteCalPickPosCommand()
        {
            try
            {
                if (ColumnNum < 1)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.请设置托盘列数, Duration = 1 });
                    return;
                }

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

                //托盘间隔
                double invt = (PickP2.Z_Position_Stop - PickP1.Z_Position_Stop) / (ColumnNum - 1);
                for (int i = 0; i < ColumnNum; i++)
                {
                    if (Points.Count - 1 <= i)
                    {
                        Points[i].Number = i + 1;
                        Points[i].X_Position = PickP1.X_Position;
                        Points[i].X_Velocity = 100;
                        Points[i].Y_Position = PickP1.Y_Position;
                        Points[i].Y_Velocity = 100;
                        Points[i].Z_Position_Start = PickP1.Z_Position_Start;
                        Points[i].Z_Velocity_Start = 100;
                        Points[i].U_Position = PickP1.U_Position;
                        Points[i].U_Velocity = 100;
                        Points[i].Z_Position_Stop = (float)(PickP1.Z_Position_Stop + i * invt);
                        Points[i].Z_Velocity_Stop = 100;
                    }
                    else
                    {
                        Points.Add(new PlcPoint()
                        {
                            Number= i + 1,
                            X_Position = PickP1.X_Position,
                            X_Velocity = 100,
                            Y_Position = PickP1.Y_Position,
                            Y_Velocity = 100,
                            Z_Position_Start = PickP1.Z_Position_Start,
                            Z_Velocity_Start = 100,
                            U_Position = PickP1.U_Position,
                            U_Velocity = 100,
                            Z_Position_Stop = (float)(PickP1.Z_Position_Stop + i * invt),
                            Z_Velocity_Stop = 100
                        });
                    }
                }
                _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>
        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>
        /// 导出所有点位到本地文件（XML）
        /// </summary>
        void ExecuteExportAllPointsCommand()
        {
            try
            {
                if (SelectProduct == null)
                {
                    MessageBox.Show(Lang.未选择产品, Lang.错误, MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

                var dlg = new SaveFileDialog();
                dlg.Filter = "Plc Product Points File|*.plcproductpoints.xml|All files|*.*";
                dlg.FileName = SelectProduct != null ? ($"{SelectProduct.Name}_allpoints_{DateTime.Now:yyyyMMdd_HHmmss}.plcproductpoints.xml") : ($"product_points_{DateTime.Now:yyyyMMdd_HHmmss}.plcproductpoints.xml");
                var res = dlg.ShowDialog();
                if (res != true) return;

                var filePath = dlg.FileName;
                // 构建导出对象
                var export = new ProductPointsExport
                {
                    SoftwareVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(),
                    ProductName = SelectProduct.Name,
                    ProductDescription = SelectProduct.Description,
                    DeviceName = _configService.GetDeviceInfo().Station,
                    Created = DateTime.Now,
                    PickCameraPoints = SelectProduct.PickCameraPoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                    PickPoints = SelectProduct.PickPoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                    SecPosCameraPoints = SelectProduct.SecPosCameraPoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                    ScrewCameraPoints = SelectProduct.ScrewCameraPoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                    ScrewCameraLocalPos1 = SelectProduct.ScrewCameraLocalPos1?.Clone() ?? new PlcPoint(),
                    ScrewCameraLocalPos2 = SelectProduct.ScrewCameraLocalPos2?.Clone() ?? new PlcPoint(),
                    ScrewPoints = SelectProduct.ScrewPoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                    CheckCameraPoints = SelectProduct.CheckCameraPoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                    RemovePoints = SelectProduct.RemovePoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                   // PressurePlacePoints = SelectProduct.PressurePlacePoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                    CameraCodePlcPoints = SelectProduct.CameraCodePlcPoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                    GunPressurePoints = SelectProduct.GunPressurePoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                    ProductPlacePoints = SelectProduct.ProductPlacePoints?.Select(p => p.Clone()).ToList() ?? new List<PlcPoint>(),
                };

                var serializer = new XmlSerializer(typeof(ProductPointsExport));
                using (var fs = File.Create(filePath))
                {
                    serializer.Serialize(fs, export);
                }
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.导出完成, Duration = 1 });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("导出点位时出错", ex);
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 导入点位文件，覆盖当前点位
        /// </summary>
        void ExecuteImportPointsCommand()
        {
            try
            {
                var dlg = new OpenFileDialog();
                dlg.Filter = "Plc Points File|*.plcproductpoints.xml|All files|*.*";
                var res = dlg.ShowDialog();
                if (res != true) return;
                var filePath = dlg.FileName;

                // 验证并读取文件（ProductPointsExport）
                var serializer = new XmlSerializer(typeof(ProductPointsExport));
                ProductPointsExport import = null;
                using (var fs = File.OpenRead(filePath))
                {
                    try
                    {
                        import = (ProductPointsExport)serializer.Deserialize(fs);
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(Lang.无效的点位文件或文件已损坏, Lang.错误, MessageBoxButton.OK, MessageBoxImage.Error);
                        LogHelper.WriteLogError("导入点位文件解析失败", ex);
                        return;
                    }
                }

                if (import == null)
                {
                    MessageBox.Show(Lang.导入的点位文件为空, Lang.提示, MessageBoxButton.OK, MessageBoxImage.Information);
                    return;
                }

                // 提示用户是否覆盖
                if (MessageBox.Show("确认要导入点位文件并覆盖当前所有点位吗", "导入点位", MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                {
                    return;
                }

                // 覆盖 SelectProduct 下的各类点集合
                SelectProduct.PickCameraPoints = new ObservableCollection<PlcPoint>(import.PickCameraPoints ?? new List<PlcPoint>());
                SelectProduct.PickPoints = new ObservableCollection<PlcPoint>(import.PickPoints ?? new List<PlcPoint>());
                SelectProduct.SecPosCameraPoints = new ObservableCollection<PlcPoint>(import.SecPosCameraPoints ?? new List<PlcPoint>());
                SelectProduct.ScrewCameraPoints = new ObservableCollection<PlcPoint>(import.ScrewCameraPoints ?? new List<PlcPoint>());
                SelectProduct.ScrewCameraLocalPos1 = import.ScrewCameraLocalPos1 ?? new PlcPoint();
                SelectProduct.ScrewCameraLocalPos2 = import.ScrewCameraLocalPos2 ?? new PlcPoint();
                SelectProduct.ScrewPoints = new ObservableCollection<PlcPoint>(import.ScrewPoints ?? new List<PlcPoint>());
                SelectProduct.CheckCameraPoints = new ObservableCollection<PlcPoint>(import.CheckCameraPoints ?? new List<PlcPoint>());
                SelectProduct.RemovePoints = new ObservableCollection<PlcPoint>(import.RemovePoints ?? new List<PlcPoint>());
                //SelectProduct.PressurePlacePoints = new ObservableCollection<PlcPoint>(import.PressurePlacePoints ?? new List<PlcPoint>());
                SelectProduct.CameraCodePlcPoints = new ObservableCollection<PlcPoint>(import.CameraCodePlcPoints ?? new List<PlcPoint>());
                SelectProduct.ProductPlacePoints = new ObservableCollection<PlcPoint>(import.ProductPlacePoints ?? new List<PlcPoint>());
                SelectProduct.GunPressurePoints = new ObservableCollection<PlcPoint>(import.GunPressurePoints ?? new List<PlcPoint>());

                // 重新编号每个集合
                Action<ObservableCollection<PlcPoint>> renumber = (col) =>
                {
                    for (int i = 0; i < col.Count; i++) col[i].Number = i + 1;
                };
                renumber(SelectProduct.PickCameraPoints);
                renumber(SelectProduct.PickPoints);
                renumber(SelectProduct.SecPosCameraPoints);
                renumber(SelectProduct.ScrewCameraPoints);
                renumber(SelectProduct.ScrewPoints);
                renumber(SelectProduct.CheckCameraPoints);
                renumber(SelectProduct.RemovePoints);
                renumber(SelectProduct.CameraCodePlcPoints);
                //renumber(SelectProduct.PressurePlacePoints);
                renumber(SelectProduct.ProductPlacePoints);
                renumber(SelectProduct.GunPressurePoints);

                // 根据当前 SelectedIndex 切换 Points 绑定到对应集合
                ExecuteSelectionChangedCommand();

                LogHelper.WriteLogDebug("导入点位文件成功");
                _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 });
            }
        }
        #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
            {
                toolCoord = null;
                SelectProduct = navigationContext.Parameters.GetValue<ProductModel>("SelectProduct");

                SelectedIndex = 0;
                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;
                    AdditionalAxisList = Robot.AdditionalAxisList;
                }
                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);
                    }
                }
                CameraList = new ObservableCollection<CameraInfo>(_configService.GetAllCameras());
                if (SelectProduct.PickPoints!=null && SelectProduct.PickPoints.Count>0)
                {
                    PickP1 = SelectProduct.PickPoints.FirstOrDefault().Clone();
                    PickP2 = SelectProduct.PickPoints.LastOrDefault().Clone();
                    ColumnNum = SelectProduct.PickPoints.Count;
                }

                if (SelectProduct.PickCameraPoints == null)
                {
                    SelectProduct.PickCameraPoints = new ObservableCollection<PlcPoint>();
                }
                if (SelectProduct.PickPoints == null)
                {
                    SelectProduct.PickPoints = new ObservableCollection<PlcPoint>();
                }
                if (SelectProduct.SecPosCameraPoints == null)
                {
                    SelectProduct.SecPosCameraPoints = new ObservableCollection<PlcPoint>();
                }
                if (SelectProduct.ScrewCameraPoints == null)
                {
                    SelectProduct.ScrewCameraPoints = new ObservableCollection<PlcPoint>();
                }
                if (SelectProduct.ScrewPoints == null)
                {
                    SelectProduct.ScrewPoints = new ObservableCollection<PlcPoint>();
                }
                if (SelectProduct.CheckCameraPoints == null)
                {
                    SelectProduct.CheckCameraPoints = new ObservableCollection<PlcPoint>();
                }
                if (SelectProduct.RemovePoints == null)
                {
                    SelectProduct.RemovePoints = new ObservableCollection<PlcPoint>();
                }
                //if (SelectProduct.PressurePlacePoints == null)
                //{
                //    SelectProduct.PressurePlacePoints = new ObservableCollection<PlcPoint>();
                //}
                if (SelectProduct.CameraCodePlcPoints == null)
                {
                    SelectProduct.CameraCodePlcPoints = new ObservableCollection<PlcPoint>();
                }
                if (SelectProduct.ProductPlacePoints == null)
                {
                    SelectProduct.ProductPlacePoints = new ObservableCollection<PlcPoint>();
                }
                if (SelectProduct.GunPressurePoints == null)
                {
                    SelectProduct.GunPressurePoints = new ObservableCollection<PlcPoint>();
                }

            }
            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


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