Display_D_HP/TeamAAS-VM/Models/Product/ProcedureModel.cs

using Cognex.VisionPro.ToolBlock;
using Newtonsoft.Json;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Models.Feeder;
using TeamAAS_VP.Models.Lights;
using TeamAAS_VP.Models.Product;

namespace TeamAAS_VP.Models
{
    /// <summary>
    /// 流程模型
    /// </summary>
    [JsonObject(MemberSerialization.OptOut)]
    public class ProcedureModel : BindableBase
    {
        public Guid Id { get; set; }

        /// <summary>
        /// 流程名称
        /// </summary>
        public string Name { get; set; }

        public string CameraName { get; set; }

        /// <summary>
        /// 视觉图像处理模式
        /// </summary>
        public VisionModel VisionModel { get; set; }

        /// <summary>
        /// 触发相机命令
        /// </summary>
        public string TriggerCommand {  get; set; }

        /// <summary>
        /// 机器人
        /// </summary>
        public Guid RobotId { get; set; }

        /// <summary>
        /// Feeder
        /// </summary>
        public Guid FeederId { get; set; }

        /// <summary>
        /// Camera
        /// </summary>
        public Guid CameraId { get; set; }

        /// <summary>
        /// 校准
        /// </summary>
        public Guid CalibrationId { get; set; }

        private ObservableCollection<ProcedureOutput> _ProcedureOutputs;

        /// <summary>
        /// 视觉流程输出集合
        /// </summary>
        public ObservableCollection<ProcedureOutput> ProcedureOutputs
        {
            get { return _ProcedureOutputs; }
            set { SetProperty(ref _ProcedureOutputs,value); }
        }

        private string _OutputSeparator = ";";
        /// <summary>
        /// 视觉流程输出项之间的分割符
        /// </summary>
        public string OutputSeparator
        {
            get { return _OutputSeparator; }
            set { SetProperty(ref _OutputSeparator, value); }
        }

        private FeederWorks _FeederWorks;

        /// <summary>
        /// Feeder振动集合
        /// </summary>
        public FeederWorks FeederWorks
        {
            get { return _FeederWorks; }
            set { SetProperty(ref _FeederWorks,value); }
        }

        private FeederStockWorks _FeederStockWorks;

        /// <summary>
        /// Feeder料仓振动集合
        /// </summary>
        public FeederStockWorks FeederStockWorks
        {
            get { return _FeederStockWorks; }
            set { SetProperty(ref _FeederStockWorks, value); }
        }

        private double _MinArea;
        /// <summary>
        /// Blob最小面积
        /// </summary>
        public double MinArea
        {
            get { return _MinArea; }
            set { SetProperty(ref _MinArea, value); }
        }

        private int _LightValue;
        /// <summary>
        /// 亮度
        /// </summary>
        public int LightValue
        {
            get { return _LightValue; }
            set { SetProperty(ref _LightValue, value); }
        }

        private float _ExposureTime;
        /// <summary>
        /// 相机曝光时间
        /// </summary>
        public float ExposureTime
        {
            get { return _ExposureTime; }
            set { SetProperty(ref _ExposureTime, value);}
        }

        private float _Gain;
        /// <summary>
        /// 相机增益
        /// </summary>
        public float Gain
        {
            get { return _Gain; }
            set { SetProperty(ref _Gain, value); }
        }

        private CogToolBlock _ToolBlock;
        /// <summary>
        /// 工具组
        /// </summary>
        [JsonIgnore]
        public CogToolBlock ToolBlock
        {
            get { return _ToolBlock; }
            set { SetProperty(ref _ToolBlock,value); }
        }

        private ObservableCollection<ToolInfo> _ToolInfo = new ObservableCollection<ToolInfo>();
        /// <summary>
        /// 工具末端的补偿
        /// </summary>
        public ObservableCollection<ToolInfo> ToolInfo
        {
            get { return _ToolInfo; }
            set { SetProperty(ref _ToolInfo, value); }
        }

        private int _WaitPhoto;
        /// <summary>
        /// 延时拍照时长(ms)
        /// </summary>
        public int WaitPhoto
        {
            get { return _WaitPhoto; }
            set { SetProperty(ref _WaitPhoto, value); }
        }

        private int _WaitFeederStop;
        /// <summary>
        /// 等待震动盘静止时长(ms)
        /// </summary>
        public int WaitFeederStop
        {
            get { return _WaitFeederStop; }
            set { SetProperty(ref _WaitFeederStop, value); }
        }

        private VibrationModel _VibrationModel;
        /// <summary>
        /// 振动模式
        /// </summary>
        public VibrationModel VibrationModel
        {
            get { return _VibrationModel; }
            set { SetProperty(ref _VibrationModel, value); }
        }

        private int _FeederFailLimit;
        /// <summary>
        /// 拍照失败Feeder振动最大次数
        /// </summary>
        public int FeederFailLimit
        {
            get { return _FeederFailLimit; }
            set { SetProperty(ref _FeederFailLimit, value); }
        }

        private OutputPointMode _OutputPointMode;
        /// <summary>
        /// 点位发送的模式
        /// </summary>
        public OutputPointMode OutputPointMode
        {
            get { return _OutputPointMode; }
            set { SetProperty(ref _OutputPointMode, value); }
        }

        private int _OutputPointCountMax=100;
        /// <summary>
        /// 每次发送给机器人的点数最大值
        /// </summary>
        public int OutputPointCountMax
        {
            get { return _OutputPointCountMax; }
            set { SetProperty(ref _OutputPointCountMax, value); }
        }

        private bool _IsExcludeNearPoint;
        /// <summary>
        /// 是否剔除本次识别到的物料与上一次识别到的物料位置过近的点
        /// </summary>
        public bool IsExcludeNearPoint
            {
            get { return _IsExcludeNearPoint; }
            set { SetProperty(ref _IsExcludeNearPoint, value); }
        }

        private double _ExcludeNearPointThreshol=1;
        /// <summary>
        /// 物料位置过近阈值
        /// </summary>
        public double ExcludeNearPointThreshol
        {
            get { return _ExcludeNearPointThreshol; }
            set { SetProperty(ref _ExcludeNearPointThreshol, value); }
        }

        private bool _IsSaveImage;
        /// <summary>
        /// 保存图像
        /// </summary>
        public bool IsSaveImage
        {
            get { return _IsSaveImage; }
            set { SetProperty(ref _IsSaveImage, value); }
        }

        private ProcedureSaveImageModel _SaveImageModel;
        /// <summary>
        /// 存图模式
        /// </summary>
        public ProcedureSaveImageModel SaveImageModel
        {
            get { return _SaveImageModel; }
            set { SetProperty(ref _SaveImageModel, value); }
        }

        private ProcedureSaveImagePathModel _SaveImagePathModel;
        /// <summary>
        /// 存图路径模式
        /// </summary>
        public ProcedureSaveImagePathModel SaveImagePathModel
        {
            get { return _SaveImagePathModel; }
            set { SetProperty(ref _SaveImagePathModel, value); }
        }

        private string _SavePath;
        /// <summary>
        /// 存图路径
        /// </summary>
        public string SavePath
        {
            get { return _SavePath; }
            set { SetProperty(ref _SavePath, value); }
        }

        private bool _IsCompress;
        /// <summary>
        /// 是否压缩图片
        /// </summary>
        public bool IsCompress
        {
            get { return _IsCompress; }
            set { SetProperty(ref _IsCompress, value); }
        }

        private FeederFrequencyModel _FeederFindFrequency;
        /// <summary>
        /// Feeder自动寻频配置
        /// </summary>
        public FeederFrequencyModel FeederFindFrequency
        {
            get { return _FeederFindFrequency; }
            set { SetProperty(ref _FeederFindFrequency, value); }
        }

        private ObservableCollection<ProcedureUserDefineParam> _UserDefineParameters;
        /// <summary>
        /// 用户自定义参数
        /// </summary>
        public ObservableCollection<ProcedureUserDefineParam> UserDefineParameters
        {
            get { return _UserDefineParameters; }
            set { SetProperty(ref _UserDefineParameters, value); }
        }

        private ObservableCollection<ChannelConfig> _LightChannels;
        /// <summary>
        /// 光源通道配置集合。每个流程可配置多个光源通道及其默认亮度。
        /// </summary>
        public ObservableCollection<ChannelConfig> LightChannels
        {
            get { return _LightChannels; }
            set { SetProperty(ref _LightChannels, value); }
        }

        #region 运行时的一些临时记忆

        /// <summary>
        /// 最后一次的Blob面积值
        /// </summary>
        [JsonIgnore]
        public double LastBlobArea { get; set; } = 0;

        /// <summary>
        /// 最后一次运行的点数据
        /// </summary>
        [JsonIgnore]
        public List<double[]> LastRunPoints { get; set; } = new List<double[]>();

        #endregion

        public ProcedureModel()
        {
            Id = Guid.NewGuid();
            ProcedureOutputs = new ObservableCollection<ProcedureOutput>();
            ToolInfo= new ObservableCollection<ToolInfo>();
            FeederFindFrequency= new FeederFrequencyModel();
            UserDefineParameters= new ObservableCollection<ProcedureUserDefineParam>();
            FeederWorks = new FeederWorks();
            FeederStockWorks= new FeederStockWorks();
            LightChannels = new ObservableCollection<ChannelConfig>();
        }

        public ProcedureModel(string name, string cameraName, Guid cameraId)
        {
            Id = Guid.NewGuid();
            Name = name;
            CameraName = cameraName;
            CameraId = cameraId;
            ProcedureOutputs = new ObservableCollection<ProcedureOutput>();
            ToolInfo = new ObservableCollection<ToolInfo>();
            FeederFindFrequency = new FeederFrequencyModel();
            UserDefineParameters = new ObservableCollection<ProcedureUserDefineParam>();
            FeederWorks = new FeederWorks();
            FeederStockWorks = new FeederStockWorks();
            LightChannels = new ObservableCollection<ChannelConfig>();
        }

        public ProcedureModel Clone()
        {
            return new ProcedureModel
            {
                Id = this.Id,
                Name = this.Name,
                CameraName=this.CameraName,
                VisionModel = this.VisionModel,
                TriggerCommand=this.TriggerCommand,
                RobotId = this.RobotId,
                FeederId = this.FeederId,
                CameraId = this.CameraId,
                CalibrationId = this.CalibrationId,
                ProcedureOutputs = new ObservableCollection<ProcedureOutput>(this.ProcedureOutputs.Select(po => po.Copy())),
                FeederWorks = this.FeederWorks?.Copy(),
                FeederStockWorks = this.FeederStockWorks?.Copy(),
                MinArea = this.MinArea,
                LightValue = this.LightValue,
                ExposureTime = this.ExposureTime,
                Gain = this.Gain,
                // ToolBlock不克隆
                ToolInfo = new ObservableCollection<ToolInfo>(this.ToolInfo.Select(ti => ti.Copy())),
                WaitPhoto = this.WaitPhoto,
                WaitFeederStop = this.WaitFeederStop,
                VibrationModel = this.VibrationModel,
                FeederFailLimit = this.FeederFailLimit,
                OutputPointCountMax = this.OutputPointCountMax,
                IsSaveImage = this.IsSaveImage,
                SaveImageModel = this.SaveImageModel,
                SaveImagePathModel = this.SaveImagePathModel,
                SavePath = this.SavePath,
                IsCompress = this.IsCompress,
                FeederFindFrequency = this.FeederFindFrequency?.Copy(),
                IsExcludeNearPoint=this.IsExcludeNearPoint,
                ExcludeNearPointThreshol = this.ExcludeNearPointThreshol,
                OutputPointMode=this.OutputPointMode,
                OutputSeparator=this.OutputSeparator,
                UserDefineParameters = new ObservableCollection<ProcedureUserDefineParam>(this.UserDefineParameters.Select(udp => udp.Copy())),
                LightChannels = this.LightChannels == null ? new ObservableCollection<ChannelConfig>() : new ObservableCollection<ChannelConfig>(this.LightChannels.Select(ch => new ChannelConfig
                {
                    Name = ch.Name,
                    Description = ch.Description,
                    LocalIndex = ch.LocalIndex,
                    GlobalIndex = ch.GlobalIndex,
                    DefaultBrightness = ch.DefaultBrightness
                })),
            };
        }
    }
}