Virgo_Mask/VirgoRT/Devices/EPDs/EPInterface/Datas/DataItemDefine.cs

using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System;

namespace EPInterface.Data
{
    //[DataContract]
    //public enum EPDState
    //{
    //    [EnumMember]
    //    UnSampling,    //硬件未进入采样

    //    [EnumMember]
    //    Running,       //计算中

    //    [EnumMember]
    //    Pause,         //暂停

    //    [EnumMember]
    //    Idle,
    //};

    //[DataContract]
    //public enum EPDEventType
    //{
    //    [EnumMember]
    //    Default = 0,    //基础信息

    //    [EnumMember]
    //    Info = 1,    //基础信息


    //    [EnumMember]
    //    Error,    //基础信息

    //    [EnumMember]
    //    Start,       //步骤 开始 

    //    [EnumMember]
    //    Delay,       //步骤 延迟 

    //    [EnumMember]
    //    Normalize,   //步骤 


    //    [EnumMember]
    //    Check,   //步骤 检查条件

    //    [EnumMember]
    //    EndPoint,   //步骤 触发

    //    [EnumMember]
    //    Stop,   //步骤 停止
    //};

    //[DataContract]
    //[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Ansi)]
    //public struct HardwareInfo
    //{
    //    [MarshalAs(UnmanagedType.U8)]
    //    public ulong Ver;
    //    [MarshalAs(UnmanagedType.U2)]
    //    public ushort Pixes;
    //    [MarshalAs(UnmanagedType.R8)]
    //    public double FirstCoefficient;
    //    [MarshalAs(UnmanagedType.R8)]
    //    public double SecondCoefficient;
    //    [MarshalAs(UnmanagedType.R8)]
    //    public double ThirdCoefficient;
    //    [MarshalAs(UnmanagedType.R8)]
    //    public double Intercept;
    //    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
    //    public char[] Serial;

    //    [MarshalAs(UnmanagedType.U8)]
    //    public ulong IntegrationTime;

    //    [MarshalAs(UnmanagedType.U8)]
    //    public ulong SamplingTime;

    //    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024)]
    //    public double[] Wave;
    //}

    //[DataContract]
    //[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Ansi)]
    //public struct RawDataItem
    //{
    //    public static readonly int Size = Marshal.SizeOf(typeof(RawDataItem));
    //    [MarshalAs(UnmanagedType.I8)]
    //    public long Ticket;

    //    [MarshalAs(UnmanagedType.I4)]    //累积次数
    //    public int Counter;

    //    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024)]  //全光谱数据
    //    public ushort[] RawData;

    //    [MarshalAs(UnmanagedType.I4)]    //波段数据
    //    public int RegionNum;

    //    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
    //    public double[] RegionData;

    //    [MarshalAs(UnmanagedType.I4)]    //趋势数据， 表达式
    //    public int TrendNum;

    //    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
    //    public double[] TrendData;
    //}


    //[DataContract]

    //public class CRawDataItem
    //{
    //    [DataMember]
    //    public long Ticket
    //    {
    //        get;set;
    //    }
    //    [DataMember]
    //    public ushort[] RawData
    //    { get;
    //      set;
    //    }

    //    [DataMember]
    //    public int RegionNum
    //    {
    //        get; set;
    //    }

    //    [DataMember]
    //    public double[] RegionData
    //    {
    //        get;set;
    //    }

    //    [DataMember]
    //    public int TrendNum
    //    {
    //        get;set;
    //    }
    //    [DataMember]
    //    public double[] TrendData
    //    {
    //        get;set;
    //    }

    //    public CRawDataItem()
    //    {
    //        Ticket = 0;
    //        RawData = new ushort[1024];

    //        RegionNum = 32;
    //        RegionData = new double[32];

    //        TrendNum = 32;
    //        TrendData = new double[32];
    //    }
    //}

    public static class EpConst
    {
        public const int MAX_BAND_COUNT = 8;
        public const int RAW_LENGTH = 4096;
        public const int DATA_LENGTH = 32;

        public const int MAX_BAND_RANGE_NM = 20;
        public const int MAX_ZERO_BAND_COUNT = 3;

        public const int NORMALIZATION_TIME = 1000;
        public const int MAX_INTERVAL = 200;

        public const int MAX_FORMULA_LEN = 256;

        public const int OFFSET_FIRST_DATA = 34664;

        public const int RAW_SIZE = RAW_LENGTH * sizeof(ushort);
        public const int DATA_SIZE = DATA_LENGTH * sizeof(double);
    }

    public enum RawDataType
    {
        None,
        OES = 1,
        IEP = 2,
        MIX = 3,
        MULTI = 4,
        Invalid = 65535
    }

    [DataContract]
    public enum EPDState
    {
        [EnumMember] UnSampling,    //硬件未进入采样

        [EnumMember] Running,       //计算中

        [EnumMember] Pause,         //暂停

        [EnumMember] Idle,

        [EnumMember] Recording,       //记录中
    };

    [DataContract]
    public enum EPDEventType
    {
        [EnumMember] Default = 0,    //基础信息
        [EnumMember] Info = 1,    //基础信息
        [EnumMember] Error = 2,    //基础信息
        [EnumMember] Start = 3,       //步骤 开始 
        [EnumMember] DelayEnd = 4,       //步骤 延迟 
        [EnumMember] Normalize = 5,   //步骤 
        [EnumMember] Check = 6,   //步骤 检查条件
        [EnumMember] EndPoint = 7,   //步骤 触发
        [EnumMember] Stop = 8,   //步骤 停止
        [EnumMember] RF_ON = 9,   // 射频 起辉
        [EnumMember] RF_OFF = 10,   // 射频 灭辉
        [EnumMember] RecipeStart = 11,  //Recipe 启动
        [EnumMember] RecipeStop = 12,   //Recipe 停止
        [EnumMember] TrendData = 0x10,   //TrendData

        [EnumMember] UserNotification = 0x11,
        [EnumMember] UserWarning = 0x12,
        [EnumMember] UserError = 0x13,
        [EnumMember] UserFault = 0x14,

        [EnumMember] SpectrumData = 0x15,   //SpectrumData

        [EnumMember] HeartBeat = 0x20,   //心跳

        [EnumMember] StepDelayEnd = 0x30,
        [EnumMember] StepCheck = 0x31,
        [EnumMember] StepOveretch = 0x32,
        [EnumMember] StepOverMaxTime = 0x33,
        [EnumMember] StepEnd = 0x34,
        [EnumMember] Satisfied = 0x35,
        [EnumMember] CheckFailed = 0x36,
        [EnumMember] OverMaxTime = 0x3A,
        [EnumMember] OverEtch = 0x3B,
        [EnumMember] WithinMinTime = 0x3C,

        [EnumMember] StepNum = 0x80,
        [EnumMember] GasEvent,
        [EnumMember] LFEvent,
        [EnumMember] HFEvent,

        [EnumMember] ReprocessClearEvent = 0x0101,
        [EnumMember] ScriptErrorMsg = 0x0102,
    };

    [DataContract]
    [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Ansi)]
    public struct HardwareInfo
    {
        [MarshalAs(UnmanagedType.U8)] public ulong Ver;

        [MarshalAs(UnmanagedType.I4)] public int Index;
        [MarshalAs(UnmanagedType.I4)] public int Pixels;

        [MarshalAs(UnmanagedType.R8)] public double FirstCoefficient;

        [MarshalAs(UnmanagedType.R8)] public double SecondCoefficient;

        [MarshalAs(UnmanagedType.R8)] public double ThirdCoefficient;

        [MarshalAs(UnmanagedType.R8)] public double Intercept;

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public char[] Serial;

        [MarshalAs(UnmanagedType.U8)] public ulong IntegrationTime;

        [MarshalAs(UnmanagedType.I4)] public int SamplingTime;

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4096)]
        public double[] Wave;
    }

    [DataContract]
    [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Ansi)]
    public struct RawDataItem : IComparable
    {
        public static readonly int Size = Marshal.SizeOf(typeof(RawDataItem));

        [MarshalAs(UnmanagedType.I8)]
        [DataMember] public long Ticket;

        [MarshalAs(UnmanagedType.I4)]
        [DataMember] public int Counter;   //累积次数

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = EpConst.RAW_LENGTH)]
        [DataMember] public ushort[] OES;          //OES

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = EpConst.RAW_LENGTH)] // with flashlamp on
        [DataMember] public ushort[] IEP;       //IEP

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = EpConst.RAW_LENGTH)] // with flashlamp off
        [DataMember] public ushort[] IEP_OES;

        [MarshalAs(UnmanagedType.I4)]
        [DataMember] public int RegionNum;   //波段数据

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = EpConst.DATA_LENGTH)]
        [DataMember] public double[] RegionData;

        [MarshalAs(UnmanagedType.I4)]
        [DataMember] public int TrendNum;   //趋势数据， 表达式

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = EpConst.DATA_LENGTH)]
        [DataMember] public double[] TrendData;

        public RawDataItem(int _)
        {
            Ticket = 0;
            Counter = 0;
            RegionNum = 0;
            TrendNum = 0;

            OES = new ushort[EpConst.RAW_LENGTH];
            IEP = new ushort[EpConst.RAW_LENGTH];
            IEP_OES = new ushort[EpConst.RAW_LENGTH];
            RegionData = new double[EpConst.DATA_LENGTH];
            TrendData = new double[EpConst.DATA_LENGTH];
        }

        public RawDataItem(RawDataItem2 item)
        {
            Ticket = item.Ticket;
            Counter = 0;
            TrendNum = item.TrendNum;
            RegionNum = item.RegionNum;

            OES = new ushort[EpConst.RAW_LENGTH];
            IEP = new ushort[EpConst.RAW_LENGTH];
            IEP_OES = new ushort[EpConst.RAW_LENGTH];
            RegionData = new double[EpConst.DATA_LENGTH];
            TrendData = new double[EpConst.DATA_LENGTH];

            if (item.OES == null)
                return;

            Buffer.BlockCopy(item.OES, 0, IEP_OES, 0, EpConst.RAW_SIZE);
            Buffer.BlockCopy(item.IEP, 0, IEP, 0, EpConst.RAW_SIZE);
            Buffer.BlockCopy(item.TrendData, 0, TrendData, 0, EpConst.DATA_SIZE);
            Buffer.BlockCopy(item.RegionData, 0, RegionData, 0, EpConst.DATA_SIZE);
        }

        public int CompareTo(object obj)
        {
            var item = (RawDataItem)obj;
            if (this.Ticket < item.Ticket) return -1;
            else if (this.Ticket > item.Ticket) return 1;
            else return 0;
        }
    }

    [DataContract]
    [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Ansi)]
    public struct RawDataItem2
    {
        public static readonly int Size = Marshal.SizeOf(typeof(RawDataItem2));

        [MarshalAs(UnmanagedType.I8)] public long Ticket;

        [MarshalAs(UnmanagedType.I4)] public int Counter;   //累积次数

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4096)]  //全光谱数据
        public ushort[] OES;          //OES

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4096)]  //全光谱数据
        public ushort[] IEP;       //IEP

        [MarshalAs(UnmanagedType.I4)] public int RegionNum;   //波段数据

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
        public double[] RegionData;

        [MarshalAs(UnmanagedType.I4)] public int TrendNum;   //趋势数据， 表达式

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
        public double[] TrendData;
    }


    [DataContract]
    public class CRawDataItem
    {
        [DataMember] public long Ticket { get; set; }

        [DataMember] public ushort[] OES { get; set; }
        [DataMember] public ushort[] IEP { get; set; }   // with flashlamp on
        [DataMember] public ushort[] IEP_OES { get; set; }  // with flashlamp off

        [DataMember] public int RegionNum { get; set; }
        [DataMember] public double[] RegionData { get; set; }

        [DataMember] public int TrendNum { get; set; }
        [DataMember] public double[] TrendData { get; set; }

        public CRawDataItem(int len = EpConst.RAW_LENGTH) : this(len, len)
        {
        }

        private void init(int oesLen, int iepLen)
        {
            Ticket = 0;

            OES = new ushort[oesLen];
            IEP = new ushort[iepLen];
            IEP_OES = new ushort[iepLen];

            RegionNum = 0;
            RegionData = new double[EpConst.DATA_LENGTH];

            TrendNum = 0;
            TrendData = new double[EpConst.DATA_LENGTH];
        }

        public CRawDataItem(int oesLen, int iepLen)
        {
            init(oesLen, iepLen);
        }

        public CRawDataItem(RawDataType type, int len = 1201)
        {
            var oesLen = type == RawDataType.IEP ? 0 : len;
            var iepLen = type == RawDataType.OES ? 0 : len;

            init(oesLen, iepLen);
        }

        public CRawDataItem(RawDataItem item, RawDataType type, int len = 1201)
        {
            var oesLen = type == RawDataType.IEP ? 0 : len;
            var iepLen = type == RawDataType.OES ? 0 : len;

            init(oesLen, iepLen);

            Buffer.BlockCopy(item.OES, 0, OES, 0, oesLen * sizeof(ushort));
            Buffer.BlockCopy(item.IEP_OES, 0, IEP_OES, 0, iepLen * sizeof(ushort));
            Buffer.BlockCopy(item.IEP, 0, IEP, 0, iepLen * sizeof(ushort));
            Buffer.BlockCopy(item.TrendData, 0, TrendData, 0, EpConst.DATA_SIZE);
            Buffer.BlockCopy(item.RegionData, 0, RegionData, 0, EpConst.DATA_SIZE);
        }
    }



}