MvvmScaffoldFrame48/MvvmScaffoldFrame48.DLL/ImageAlgorithm/CPUDeepObjectDetectClass.cs

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