20251104 分支创建，添加海康的SDK算子及引用和测试实现

MvvmScaffoldFrame48.DLL/ImageAlgorithm/CPUDeepObjectDetectClass.cs

@@ -0,0 +1,783 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using VisionDesigner;
+using VisionDesigner.MVDCNNDetect;
+
+namespace MvvmScaffoldFrame48.DLL.ImageAlgorithm
+{
+    public class CPUDeepObjectDetectClass
+    {
+        private CNNDetectTool m_stCNNDetectToolObj = null;
+        private CMvdXmlParseTool m_stXmlParseToolObj = null;
+        private CMvdImage m_stInputImage = null;
+        List<CMvdRectangleF> m_lBlobBoxRender1 = new List<CMvdRectangleF>();
+        private CMvdShape m_stROIShape = null;
+        private MVD_ALGORITHM_PLATFORM_TYPE m_enPlatformType = MVD_ALGORITHM_PLATFORM_TYPE.MVD_ALGORITHM_PLATFORM_CPU;
+        MVD_CNN_CROP_TYPE m_enCropRoiType = MVD_CNN_CROP_TYPE.MVD_CNN_ROI_TYPE_NORMAL;
+        MVD_CNN_PREDICT_MODE m_enPredictMode = MVD_CNN_PREDICT_MODE.MVD_CNN_PREDICT_NORMAL;
+
+        public CPUDeepObjectDetectClass()
+        {
+            m_stCNNDetectToolObj = new CNNDetectTool(m_enPlatformType);
+            byte[] fileBytes = new byte[256];
+            uint nConfigDataSize = 256;
+            uint nConfigDataLen = 0;
+            try
+            {
+                m_stCNNDetectToolObj.SaveConfiguration(fileBytes, nConfigDataSize, ref nConfigDataLen);
+            }
+            catch (MvdException ex)
+            {
+                if (MVD_ERROR_CODE.MVD_E_NOENOUGH_BUF == ex.ErrorCode)
+                {
+                    fileBytes = new byte[nConfigDataLen];
+                    nConfigDataSize = nConfigDataLen;
+                    m_stCNNDetectToolObj.SaveConfiguration(fileBytes, nConfigDataSize, ref nConfigDataLen);
+                }
+                else
+                {
+                    throw ex;
+                }
+            }
+            UpdateParamList(fileBytes, nConfigDataLen);
+        }
+
+
+        /// <summary>
+        /// 加载图片
+        /// </summary>
+        /// <param name="LoadImagePath"></param>
+        public void LoadImage(string LoadImagePath)
+        {
+            try
+            {
+                if (!string.IsNullOrEmpty(LoadImagePath))
+                {
+                    if (null == m_stInputImage)
+                    {
+                        m_stInputImage = new CMvdImage();
+                    }
+                    m_stInputImage.InitImage(LoadImagePath);
+                    m_stROIShape = null;
+                    m_lBlobBoxRender1.Clear();
+
+                    Console.WriteLine("Finish loading image from [" + LoadImagePath + "].");
+                }
+            }
+            catch (MvdException ex)
+            {
+                Console.WriteLine("Fail to load image from [" + LoadImagePath + "]. ErrorCode: 0x" + ex.ErrorCode.ToString("X"));
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("Fail to load image from [" + LoadImagePath + "]. Error: " + ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// 加载图片
+        /// </summary>
+        /// <param name="bitmap"></param>
+        public void LoadImage(Bitmap bitmap)
+        {
+            try
+            {
+                if (bitmap != null)
+                {
+                    if (null == m_stInputImage)
+                    {
+                        m_stInputImage = new CMvdImage();
+                    }
+                    m_stInputImage.InitImage(bitmap);
+                    m_stROIShape = null;
+                    m_lBlobBoxRender1.Clear();
+
+                    Console.WriteLine("Finish loading image from [BitMap].");
+                }
+            }
+            catch (MvdException ex)
+            {
+                Console.WriteLine("Fail to load image from [BitMap]. ErrorCode: 0x" + ex.ErrorCode.ToString("X"));
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("Fail to load image from [BitMap]. Error: " + ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// 加载模型
+        /// </summary>
+        public void LoadDeepModel(string modelPath)
+        {
+            try
+            {
+                if (!string.IsNullOrEmpty(modelPath))
+                {
+                    m_stCNNDetectToolObj.BasicParam.LoadModel(modelPath);
+
+                    Console.WriteLine("Finish loading model from [" + modelPath + "].");
+                }
+            }
+            catch (MvdException ex)
+            {
+                Console.WriteLine("Fail to load model from [" + modelPath + "]. ErrorCode: 0x" + ex.ErrorCode.ToString("X"));
+            }
+            catch (System.Exception ex)
+            {
+                Console.WriteLine("Fail to load model from [" + modelPath + "]. Error: " + ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// 运行检测
+        /// </summary>
+        public List<CNNDetectPredInfo> RunDetect()
+        {
+
+            List<CNNDetectPredInfo> Result = new List<CNNDetectPredInfo>();
+            try
+            {
+                if ((null == m_stCNNDetectToolObj) || (null == m_stInputImage))
+                {
+                    throw new MvdException(MVD_MODULE_TYPE.MVD_MODUL_APP, MVD_ERROR_CODE.MVD_E_CALLORDER);
+                }
+
+                m_stCNNDetectToolObj.InputImage = m_stInputImage;
+
+                if (null == m_stROIShape)
+                {
+                    m_stCNNDetectToolObj.ROI = new VisionDesigner.CMvdRectangleF(m_stInputImage.Width / 2, m_stInputImage.Height / 2, m_stInputImage.Width, m_stInputImage.Height);
+                }
+                else
+                {
+                    m_stCNNDetectToolObj.ROI = m_stROIShape;
+                }
+
+                //设置基本参数
+                m_stCNNDetectToolObj.BasicParam.PredictMode = m_enPredictMode;
+                m_stCNNDetectToolObj.BasicParam.RoiCropType = m_enCropRoiType;
+                m_stCNNDetectToolObj.BasicParam.SODParam.Col = Convert.ToUInt32(1);
+                m_stCNNDetectToolObj.BasicParam.SODParam.Row = Convert.ToUInt32(1);
+                m_stCNNDetectToolObj.BasicParam.SODParam.Overlap = Convert.ToSingle(0.01);
+
+                m_stCNNDetectToolObj.BasicParam.BatchSize = Convert.ToInt32(4);
+                m_stCNNDetectToolObj.BasicParam.BatchSizeEnable = false;
+
+                if (m_enPlatformType != MVD_ALGORITHM_PLATFORM_TYPE.MVD_ALGORITHM_PLATFORM_GPU)
+                {
+                    m_stCNNDetectToolObj.BasicParam.BatchSizeEnable = false;
+                }
+                m_stCNNDetectToolObj.SetRunParam("MaxObjNum", "100");
+                m_stCNNDetectToolObj.Run();
+
+                if (0 != m_lBlobBoxRender1.Count)
+                {
+                    m_lBlobBoxRender1.Clear();
+                }
+
+                Console.WriteLine("Obj Num : " + m_stCNNDetectToolObj.Result.PredInfoList.Count);
+                Result = m_stCNNDetectToolObj.Result.PredInfoList;
+
+                foreach (var item in m_stCNNDetectToolObj.Result.PredInfoList)
+                {
+                    CMvdRectangleF ObjBox = new CMvdRectangleF(item.Box.CenterX, item.Box.CenterY, item.Box.Width, item.Box.Height);
+                    ObjBox.Angle = item.Box.Angle;
+                    ObjBox.BorderColor = new MVD_COLOR(0, 255, 0, 255);
+                    m_lBlobBoxRender1.Add(ObjBox);
+                }
+            }
+            catch (MvdException ex)
+            {
+                Console.WriteLine("Fail to execute algorithm tool. nRet = 0x" + ex.ErrorCode.ToString("X") + ". " + ex.Message.ToString());
+            }
+            catch (System.Exception ex)
+            {
+                Console.WriteLine(ex.Message + ex.Source + ex.StackTrace);
+            }
+            return Result;
+        }
+
+        /// <summary>
+        /// Update paramters
+        /// </summary>
+        /// <param name="bufXml"></param>
+        /// <param name="nXmlLen"></param>
+        private void UpdateParamList(Byte[] bufXml, uint nXmlLen)
+        {
+            if (null == m_stXmlParseToolObj)
+            {
+                m_stXmlParseToolObj = new CMvdXmlParseTool(bufXml, nXmlLen);
+            }
+            else
+            {
+                m_stXmlParseToolObj.UpdateXmlBuf(bufXml, nXmlLen);
+            }
+            for (int i = 0; i < m_stXmlParseToolObj.IntValueList.Count; ++i)
+            {
+                Console.WriteLine("{0}:{1}", m_stXmlParseToolObj.IntValueList[i].Description, m_stXmlParseToolObj.IntValueList[i].CurValue);
+            }
+
+            for (int i = 0; i < m_stXmlParseToolObj.EnumValueList.Count; ++i)
+            {
+                Console.WriteLine("{0}:{1}", m_stXmlParseToolObj.EnumValueList[i].Description, m_stXmlParseToolObj.EnumValueList[i].CurValue.Name);
+            }
+
+            for (int i = 0; i < m_stXmlParseToolObj.FloatValueList.Count; ++i)
+            {
+                Console.WriteLine("{0}:{1}", m_stXmlParseToolObj.FloatValueList[i].Description, m_stXmlParseToolObj.FloatValueList[i].CurValue);
+            }
+
+            for (int i = 0; i < m_stXmlParseToolObj.BooleanValueList.Count; ++i)
+            {
+                Console.WriteLine("{0}:{1}", m_stXmlParseToolObj.BooleanValueList[i].Description, m_stXmlParseToolObj.BooleanValueList[i].CurValue.ToString());
+            }
+        }
+    }
+
+    public class CMvdXmlParseTool
+    {
+        private List<CMvdNodeInteger> m_listIntValue = null;
+        private List<CMvdNodeEnumeration> m_listEnumValue = null;
+        private List<CMvdNodeFloat> m_listFloatValue = null;
+        private List<CMvdNodeBoolean> m_listBooleanValue = null;
+
+        public CMvdXmlParseTool(Byte[] bufXml, uint nXmlLen)
+        {
+            m_listIntValue = new List<CMvdNodeInteger>();
+            m_listEnumValue = new List<CMvdNodeEnumeration>();
+            m_listFloatValue = new List<CMvdNodeFloat>();
+            m_listBooleanValue = new List<CMvdNodeBoolean>();
+            UpdateXmlBuf(bufXml, nXmlLen);
+        }
+
+        public List<CMvdNodeInteger> IntValueList
+        {
+            get
+            {
+                return m_listIntValue;
+            }
+        }
+
+        public List<CMvdNodeEnumeration> EnumValueList
+        {
+            get
+            {
+                return m_listEnumValue;
+            }
+        }
+
+        public List<CMvdNodeFloat> FloatValueList
+        {
+            get
+            {
+                return m_listFloatValue;
+            }
+        }
+
+        public List<CMvdNodeBoolean> BooleanValueList
+        {
+            get
+            {
+                return m_listBooleanValue;
+            }
+        }
+
+        public void UpdateXmlBuf(Byte[] bufXml, uint nXmlLen)
+        {
+            XmlDocument xmlDoc = new XmlDocument();
+            XmlReaderSettings settings = new XmlReaderSettings();
+            settings.IgnoreComments = true;    //忽略文档里面的注释
+            XmlReader reader = XmlReader.Create(new MemoryStream(bufXml, 0, (int)nXmlLen), settings);
+            xmlDoc.Load(reader);
+            reader.Close();
+            m_listIntValue.Clear();
+            m_listEnumValue.Clear();
+            m_listFloatValue.Clear();
+            m_listBooleanValue.Clear();
+            XmlNode xnCategory = xmlDoc.SelectSingleNode("AlgorithmRoot").SelectSingleNode("Category");
+            foreach (XmlNode xn in xnCategory)
+            {
+                switch (xn.Name)
+                {
+                    case "Integer":
+                        {
+                            CMvdNodeInteger NodeInt = new CMvdNodeInteger();
+                            NodeInt.Name = ((XmlElement)xn).GetAttribute("Name");
+                            NodeInt.Description = xn.SelectSingleNode("Description").InnerText;
+                            NodeInt.DisplayName = xn.SelectSingleNode("DisplayName").InnerText;
+                            NodeInt.Visibility = xn.SelectSingleNode("Visibility").InnerText;
+                            NodeInt.AccessMode = xn.SelectSingleNode("AccessMode").InnerText;
+                            NodeInt.AlgorithmIndex = IntStringToInt(xn.SelectSingleNode("AlgorithmIndex").InnerText);
+                            NodeInt.CurValue = IntStringToInt(xn.SelectSingleNode("CurValue").InnerText);
+                            NodeInt.DefaultValue = IntStringToInt(xn.SelectSingleNode("DefaultValue").InnerText);
+                            NodeInt.MinValue = IntStringToInt(xn.SelectSingleNode("MinValue").InnerText);
+                            NodeInt.MaxValue = IntStringToInt(xn.SelectSingleNode("MaxValue").InnerText);
+                            NodeInt.IncValue = IntStringToInt(xn.SelectSingleNode("IncValue").InnerText);
+                            m_listIntValue.Add(NodeInt);
+                        }
+                        break;
+                    case "Enumeration":
+                        {
+                            CMvdNodeEnumeration NodeEnum = new CMvdNodeEnumeration();
+                            NodeEnum.Name = ((XmlElement)xn).GetAttribute("Name");
+                            NodeEnum.Description = xn.SelectSingleNode("Description").InnerText;
+                            NodeEnum.DisplayName = xn.SelectSingleNode("DisplayName").InnerText;
+                            NodeEnum.Visibility = xn.SelectSingleNode("Visibility").InnerText;
+                            NodeEnum.AccessMode = xn.SelectSingleNode("AccessMode").InnerText;
+                            NodeEnum.AlgorithmIndex = IntStringToInt(xn.SelectSingleNode("AlgorithmIndex").InnerText);
+                            int nCurValue = IntStringToInt(xn.SelectSingleNode("CurValue").InnerText);
+                            int nDefaultValue = IntStringToInt(xn.SelectSingleNode("DefaultValue").InnerText);
+                            XmlNodeList xnlEnumEntry = xn.SelectNodes("EnumEntry");
+                            List<CMvdNodeEnumEntry> clistNodeEnumEntry = new List<CMvdNodeEnumEntry>();
+                            foreach (XmlNode xnEnumEntry in xnlEnumEntry)
+                            {
+                                CMvdNodeEnumEntry cNodeEnumEntry = new CMvdNodeEnumEntry();
+                                cNodeEnumEntry.Name = ((XmlElement)xnEnumEntry).GetAttribute("Name");
+                                cNodeEnumEntry.Description = xnEnumEntry.SelectSingleNode("Description").InnerText;
+                                cNodeEnumEntry.DisplayName = xnEnumEntry.SelectSingleNode("DisplayName").InnerText;
+                                cNodeEnumEntry.Value = IntStringToInt(xnEnumEntry.SelectSingleNode("Value").InnerText);
+                                clistNodeEnumEntry.Add(cNodeEnumEntry);
+                                if (nCurValue == cNodeEnumEntry.Value)
+                                {
+                                    NodeEnum.CurValue = cNodeEnumEntry;
+                                }
+                                if (nDefaultValue == cNodeEnumEntry.Value)
+                                {
+                                    NodeEnum.DefaultValue = cNodeEnumEntry;
+                                }
+                            }
+                            NodeEnum.EnumRange = clistNodeEnumEntry;
+                            m_listEnumValue.Add(NodeEnum);
+                        }
+                        break;
+                    case "Float":
+                        {
+                            CMvdNodeFloat NodeFloat = new CMvdNodeFloat();
+                            NodeFloat.Name = ((XmlElement)xn).GetAttribute("Name");
+                            NodeFloat.Description = xn.SelectSingleNode("Description").InnerText;
+                            NodeFloat.DisplayName = xn.SelectSingleNode("DisplayName").InnerText;
+                            NodeFloat.Visibility = xn.SelectSingleNode("Visibility").InnerText;
+                            NodeFloat.AccessMode = xn.SelectSingleNode("AccessMode").InnerText;
+                            NodeFloat.AlgorithmIndex = IntStringToInt(xn.SelectSingleNode("AlgorithmIndex").InnerText);
+                            NodeFloat.CurValue = System.Convert.ToSingle(xn.SelectSingleNode("CurValue").InnerText);
+                            NodeFloat.DefaultValue = System.Convert.ToSingle(xn.SelectSingleNode("DefaultValue").InnerText);
+                            NodeFloat.MinValue = System.Convert.ToSingle(xn.SelectSingleNode("MinValue").InnerText);
+                            NodeFloat.MaxValue = System.Convert.ToSingle(xn.SelectSingleNode("MaxValue").InnerText);
+                            NodeFloat.IncValue = System.Convert.ToSingle(xn.SelectSingleNode("IncValue").InnerText);
+                            m_listFloatValue.Add(NodeFloat);
+                        }
+                        break;
+                    case "Boolean":
+                        {
+                            CMvdNodeBoolean NodeBoolean = new CMvdNodeBoolean();
+                            NodeBoolean.Name = ((XmlElement)xn).GetAttribute("Name");
+                            NodeBoolean.Description = xn.SelectSingleNode("Description").InnerText;
+                            NodeBoolean.DisplayName = xn.SelectSingleNode("DisplayName").InnerText;
+                            NodeBoolean.Visibility = xn.SelectSingleNode("Visibility").InnerText;
+                            NodeBoolean.AccessMode = xn.SelectSingleNode("AccessMode").InnerText;
+                            NodeBoolean.AlgorithmIndex = IntStringToInt(xn.SelectSingleNode("AlgorithmIndex").InnerText);
+                            NodeBoolean.CurValue = xn.SelectSingleNode("CurValue").InnerText.Equals("true", StringComparison.OrdinalIgnoreCase) == true ? true : false;
+                            NodeBoolean.DefaultValue = xn.SelectSingleNode("DefaultValue").InnerText.Equals("true", StringComparison.OrdinalIgnoreCase) == true ? true : false;
+                            m_listBooleanValue.Add(NodeBoolean);
+                        }
+                        break;
+                    default:
+                        {
+                            throw new VisionDesigner.MvdException(VisionDesigner.MVD_MODULE_TYPE.MVD_MODUL_APP
+                                                                , VisionDesigner.MVD_ERROR_CODE.MVD_E_SUPPORT
+                                                                , "Algorithm type not support!");
+                        }
+                }
+            }
+        }
+
+        public void ClearXmlBuf()
+        {
+            m_listIntValue.Clear();
+            m_listEnumValue.Clear();
+            m_listFloatValue.Clear();
+            m_listBooleanValue.Clear();
+        }
+
+        private int IntStringToInt(string strIntString)
+        {
+            if (strIntString.Contains("0x") || strIntString.Contains("0X"))
+            {
+                return Convert.ToInt32(strIntString, 16);
+            }
+            else
+            {
+                return Convert.ToInt32(strIntString, 10);
+            }
+        }
+    }
+
+    public class CMvdNodeBase
+    {
+        string m_strName = string.Empty;
+        string m_strDescription = string.Empty;
+        string m_strDisplayName = string.Empty;
+        string m_strVisibility = string.Empty;
+        string m_strAccessMode = string.Empty;
+        int m_nAlgorithmIndex = 0;
+
+        public string Name
+        {
+            get
+            {
+                return m_strName;
+            }
+            set
+            {
+                m_strName = value;
+            }
+        }
+
+        public string Description
+        {
+            get
+            {
+                return m_strDescription;
+            }
+            set
+            {
+                m_strDescription = value;
+            }
+        }
+
+        public string DisplayName
+        {
+            get
+            {
+                return m_strDisplayName;
+            }
+            set
+            {
+                m_strDisplayName = value;
+            }
+        }
+
+        public string Visibility
+        {
+            get
+            {
+                return m_strVisibility;
+            }
+            set
+            {
+                m_strVisibility = value;
+            }
+        }
+
+        public string AccessMode
+        {
+            get
+            {
+                return m_strAccessMode;
+            }
+            set
+            {
+                m_strAccessMode = value;
+            }
+        }
+
+        public int AlgorithmIndex
+        {
+            get
+            {
+                return m_nAlgorithmIndex;
+            }
+            set
+            {
+                m_nAlgorithmIndex = value;
+            }
+        }
+    }
+
+    public class CMvdNodeInteger : CMvdNodeBase
+    {
+        int m_nCurValue = 0;
+        int m_nDefaultValue = 0;
+        int m_nMinValue = 0;
+        int m_nMaxValue = 0;
+        int m_nIncValue = 0;
+
+        public int CurValue
+        {
+            get
+            {
+                return m_nCurValue;
+            }
+            set
+            {
+                m_nCurValue = value;
+            }
+        }
+
+        public int DefaultValue
+        {
+            get
+            {
+                return m_nDefaultValue;
+            }
+            set
+            {
+                m_nDefaultValue = value;
+            }
+        }
+
+        public int MinValue
+        {
+            get
+            {
+                return m_nMinValue;
+            }
+            set
+            {
+                m_nMinValue = value;
+            }
+        }
+
+        public int MaxValue
+        {
+            get
+            {
+                return m_nMaxValue;
+            }
+            set
+            {
+                m_nMaxValue = value;
+            }
+        }
+
+        public int IncValue
+        {
+            get
+            {
+                return m_nIncValue;
+            }
+            set
+            {
+                m_nIncValue = value;
+            }
+        }
+    }
+
+    public class CMvdNodeEnumEntry
+    {
+        string m_strName = string.Empty;
+        string m_strDescription = string.Empty;
+        string m_strDisplayName = string.Empty;
+        bool m_bIsImplemented = false;
+        int m_nValue = 0;
+
+        public string Name
+        {
+            get
+            {
+                return m_strName;
+            }
+            set
+            {
+                m_strName = value;
+            }
+        }
+
+        public string Description
+        {
+            get
+            {
+                return m_strDescription;
+            }
+            set
+            {
+                m_strDescription = value;
+            }
+        }
+
+        public string DisplayName
+        {
+            get
+            {
+                return m_strDisplayName;
+            }
+            set
+            {
+                m_strDisplayName = value;
+            }
+        }
+
+        public bool IsImplemented
+        {
+            get
+            {
+                return m_bIsImplemented;
+            }
+            set
+            {
+                m_bIsImplemented = value;
+            }
+        }
+
+        public int Value
+        {
+            get
+            {
+                return m_nValue;
+            }
+            set
+            {
+                m_nValue = value;
+            }
+        }
+    }
+
+    public class CMvdNodeFloat : CMvdNodeBase
+    {
+        float m_fCurValue = 0;
+        float m_fDefaultValue = 0;
+        float m_fMinValue = 0;
+        float m_fMaxValue = 0;
+        float m_fIncValue = 0;
+
+        public float CurValue
+        {
+            get
+            {
+                return m_fCurValue;
+            }
+            set
+            {
+                m_fCurValue = value;
+            }
+        }
+
+        public float DefaultValue
+        {
+            get
+            {
+                return m_fDefaultValue;
+            }
+            set
+            {
+                m_fDefaultValue = value;
+            }
+        }
+
+        public float MinValue
+        {
+            get
+            {
+                return m_fMinValue;
+            }
+            set
+            {
+                m_fMinValue = value;
+            }
+        }
+
+        public float MaxValue
+        {
+            get
+            {
+                return m_fMaxValue;
+            }
+            set
+            {
+                m_fMaxValue = value;
+            }
+        }
+
+        public float IncValue
+        {
+            get
+            {
+                return m_fIncValue;
+            }
+            set
+            {
+                m_fIncValue = value;
+            }
+        }
+    }
+
+    public class CMvdNodeBoolean : CMvdNodeBase
+    {
+        bool m_bDefaultValue = false;
+        bool m_bCurValue = false;
+
+        public bool CurValue
+        {
+            get
+            {
+                return m_bCurValue;
+            }
+            set
+            {
+                m_bCurValue = value;
+            }
+        }
+
+        public bool DefaultValue
+        {
+            get
+            {
+                return m_bDefaultValue;
+            }
+            set
+            {
+                m_bDefaultValue = value;
+            }
+        }
+    }
+
+    public class CMvdNodeEnumeration : CMvdNodeBase
+    {
+        CMvdNodeEnumEntry m_eCurValue = new CMvdNodeEnumEntry();
+        CMvdNodeEnumEntry m_eDefaultValue = new CMvdNodeEnumEntry();
+        List<CMvdNodeEnumEntry> m_listEnumEntry = new List<CMvdNodeEnumEntry>();
+
+        public CMvdNodeEnumEntry CurValue
+        {
+            get
+            {
+                return m_eCurValue;
+            }
+            set
+            {
+                m_eCurValue = value;
+            }
+        }
+
+        public CMvdNodeEnumEntry DefaultValue
+        {
+            get
+            {
+                return m_eDefaultValue;
+            }
+            set
+            {
+                m_eDefaultValue = value;
+            }
+        }
+
+        public List<CMvdNodeEnumEntry> EnumRange
+        {
+            get
+            {
+                return m_listEnumEntry;
+            }
+            set
+            {
+                m_listEnumEntry = value;
+            }
+        }
+    }
+}

MvvmScaffoldFrame48.DLL/MvvmScaffoldFrame48.Dll.csproj

@@ -54,6 +54,26 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>DLL\MvCameraControl.Net.dll</HintPath>
     </Reference>
+    <Reference Include="MVDCNNDetect.Net, Version=4.2.1.4, Culture=neutral, PublicKeyToken=f4e2bfa0ac20f5c4, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>DLL\MVDCNNDetect.Net.dll</HintPath>
+    </Reference>
+    <Reference Include="MVDCommonTool.Net, Version=4.2.1.4, Culture=neutral, PublicKeyToken=fa74ba48aa050387, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>DLL\MVDCommonTool.Net.dll</HintPath>
+    </Reference>
+    <Reference Include="MVDCore.Net, Version=4.2.1.4, Culture=neutral, PublicKeyToken=1325730a174c0650, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>DLL\MVDCore.Net.dll</HintPath>
+    </Reference>
+    <Reference Include="MVDImage.Net, Version=4.2.1.4, Culture=neutral, PublicKeyToken=ce2c144a3e6a9a93, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>DLL\MVDImage.Net.dll</HintPath>
+    </Reference>
+    <Reference Include="MVDShape.Net, Version=4.2.1.4, Culture=neutral, PublicKeyToken=a59215ef735587a6, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>DLL\MVDShape.Net.dll</HintPath>
+    </Reference>
     <Reference Include="MvFGCtrlC.Net, Version=1.0.0.0, Culture=neutral, PublicKeyToken=52fddfb3f94be800, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>DLL\MvFGCtrlC.Net.dll</HintPath>
@@ -79,6 +99,7 @@
     <Compile Include="ConfigTools\XMLReadWrite.cs" />
     <Compile Include="FileTools\PDFGenerate.cs" />
     <Compile Include="ImageAlgorithm\BoundRectangleClass.cs" />
+    <Compile Include="ImageAlgorithm\CPUDeepObjectDetectClass.cs" />
     <Compile Include="LogTools\TxtLog.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="UserManager.cs" />
@@ -92,6 +113,11 @@
   </ItemGroup>
   <ItemGroup>
     <Content Include="DLL\MvCameraControl.Net.dll" />
+    <Content Include="DLL\MVDCNNDetect.Net.dll" />
+    <Content Include="DLL\MVDCommonTool.Net.dll" />
+    <Content Include="DLL\MVDCore.Net.dll" />
+    <Content Include="DLL\MVDImage.Net.dll" />
+    <Content Include="DLL\MVDShape.Net.dll" />
     <Content Include="DLL\MvFGCtrlC.Net.dll" />
   </ItemGroup>
   <ItemGroup>