WindowsFormsTest/HikangSDK/CPUDeepObjectDetectCLass.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Runtime.InteropServices;
using System.Xml;
using VisionDesigner;
using VisionDesigner.MVDCNNDetect;

namespace HikangSDK
{
    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);
                    ConvertBitmap2MVDImage(bitmap, m_stInputImage);
                    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());
            }
        }

        private static void ConvertBitmap2MVDImage(Bitmap cBitmapImg, CMvdImage cMvdImg)
        {
            // 参数合法性判断
            if (null == cBitmapImg || null == cMvdImg)
            {
                throw new MvdException(MVD_MODULE_TYPE.MVD_MODUL_APP, MVD_ERROR_CODE.MVD_E_PARAMETER_ILLEGAL);
            }

            // 判断像素格式
            if (PixelFormat.Format8bppIndexed != cBitmapImg.PixelFormat && PixelFormat.Format24bppRgb != cBitmapImg.PixelFormat)
            {
                throw new MvdException(MVD_MODULE_TYPE.MVD_MODUL_APP, MVD_ERROR_CODE.MVD_E_SUPPORT);
            }

            Int32 nImageWidth = cBitmapImg.Width;
            Int32 nImageHeight = cBitmapImg.Height;
            Int32 nChannelNum = 0;
            BitmapData bitmapData = null;

            try
            {
                // 获取图像信息
                if (PixelFormat.Format8bppIndexed == cBitmapImg.PixelFormat) // 灰度图
                {
                    bitmapData = cBitmapImg.LockBits(new Rectangle(0, 0, nImageWidth, nImageHeight)
                                                                    , ImageLockMode.ReadOnly
                                                                    , PixelFormat.Format8bppIndexed);
                    cMvdImg.InitImage(Convert.ToUInt32(nImageWidth), Convert.ToUInt32(nImageHeight), MVD_PIXEL_FORMAT.MVD_PIXEL_MONO_08);
                    nChannelNum = 1;
                }
                else if (PixelFormat.Format24bppRgb == cBitmapImg.PixelFormat) // 彩色图
                {
                    bitmapData = cBitmapImg.LockBits(new Rectangle(0, 0, nImageWidth, nImageHeight)
                                                                , ImageLockMode.ReadOnly
                                                                , PixelFormat.Format24bppRgb);
                    cMvdImg.InitImage(Convert.ToUInt32(nImageWidth), Convert.ToUInt32(nImageHeight), MVD_PIXEL_FORMAT.MVD_PIXEL_RGB_RGB24_C3);
                    nChannelNum = 3;
                }

                // 考虑图像是否4字节对齐，bitmap要求4字节对齐，而mvdimage不要求对齐
                if (0 == nImageWidth % 4) // 4字节对齐时，直接拷贝
                {
                    Marshal.Copy(bitmapData.Scan0, cMvdImg.GetImageData().stDataChannel[0].arrDataBytes, 0, nImageWidth * nImageHeight * nChannelNum);
                }
                else // 按步长逐行拷贝
                {
                    // 每行实际占用字节数
                    Int32 nRowPixelByteNum = nImageWidth * nChannelNum + 4 - (nImageWidth * nChannelNum % 4);
                    // 每行首字节首地址
                    IntPtr bitmapDataRowPos = IntPtr.Zero;
                    for (int i = 0; i < nImageHeight; i++)
                    {
                        // 获取每行第一个像素值的首地址
                        bitmapDataRowPos = new IntPtr(bitmapData.Scan0.ToInt64() + nRowPixelByteNum * i);
                        Marshal.Copy(bitmapDataRowPos, cMvdImg.GetImageData().stDataChannel[0].arrDataBytes, i * nImageWidth * nChannelNum, nImageWidth * nChannelNum);
                    }
                }

                // bitmap彩色图按BGR存储，而MVDimg按RGB存储，改变存储顺序
                // 交换R和B
                if (PixelFormat.Format24bppRgb == cBitmapImg.PixelFormat)
                {
                    byte bTemp;
                    byte[] bMvdImgData = cMvdImg.GetImageData().stDataChannel[0].arrDataBytes;
                    for (int i = 0; i < nImageWidth * nImageHeight; i++)
                    {
                        bTemp = bMvdImgData[3 * i];
                        bMvdImgData[3 * i] = bMvdImgData[3 * i + 2];
                        bMvdImgData[3 * i + 2] = bTemp;
                    }
                }
            }
            finally
            {
                cBitmapImg.UnlockBits(bitmapData);
            }
        }

        private static void ConvertMVDImage2Bitmap(CMvdImage cMvdImg, ref Bitmap cBitmapImg)
        {
            // 参数合法性判断
            if (null == cMvdImg)
            {
                throw new MvdException(MVD_MODULE_TYPE.MVD_MODUL_APP, MVD_ERROR_CODE.MVD_E_PARAMETER_ILLEGAL);
            }

            // 判断像素格式
            if (MVD_PIXEL_FORMAT.MVD_PIXEL_MONO_08 != cMvdImg.PixelFormat && MVD_PIXEL_FORMAT.MVD_PIXEL_RGB_RGB24_C3 != cMvdImg.PixelFormat)
            {
                throw new MvdException(MVD_MODULE_TYPE.MVD_MODUL_APP, MVD_ERROR_CODE.MVD_E_SUPPORT);
            }

            Int32 nImageWidth = Convert.ToInt32(cMvdImg.Width);
            Int32 nImageHeight = Convert.ToInt32(cMvdImg.Height);
            Int32 nChannelNum = 0;
            BitmapData bitmapData = null;
            byte[] bBitmapDataTemp = null;
            try
            {
                // 获取图像信息
                if (MVD_PIXEL_FORMAT.MVD_PIXEL_MONO_08 == cMvdImg.PixelFormat) // 灰度图
                {
                    cBitmapImg = new Bitmap(nImageWidth, nImageHeight, PixelFormat.Format8bppIndexed);

                    // 灰度图需指定调色板
                    ColorPalette colorPalette = cBitmapImg.Palette;
                    for (int j = 0; j < 256; j++)
                    {
                        colorPalette.Entries[j] = Color.FromArgb(j, j, j);
                    }
                    cBitmapImg.Palette = colorPalette;

                    bitmapData = cBitmapImg.LockBits(new Rectangle(0, 0, nImageWidth, nImageHeight)
                                                                    , ImageLockMode.WriteOnly
                                                                    , PixelFormat.Format8bppIndexed);

                    // 灰度图不做深拷贝
                    bBitmapDataTemp = cMvdImg.GetImageData().stDataChannel[0].arrDataBytes;
                    nChannelNum = 1;
                }
                else if (MVD_PIXEL_FORMAT.MVD_PIXEL_RGB_RGB24_C3 == cMvdImg.PixelFormat) // 彩色图
                {
                    cBitmapImg = new Bitmap(nImageWidth, nImageHeight, PixelFormat.Format24bppRgb);
                    bitmapData = cBitmapImg.LockBits(new Rectangle(0, 0, nImageWidth, nImageHeight)
                                                                , ImageLockMode.WriteOnly
                                                                , PixelFormat.Format24bppRgb);
                    // 彩色图做深拷贝
                    bBitmapDataTemp = new byte[cMvdImg.GetImageData().stDataChannel[0].nLen];
                    Array.Copy(cMvdImg.GetImageData().stDataChannel[0].arrDataBytes, bBitmapDataTemp, bBitmapDataTemp.Length);
                    nChannelNum = 3;
                }

                // bitmap彩色图按BGR存储，而MVDimg按RGB存储，改变存储顺序
                // 交换R和B
                if (MVD_PIXEL_FORMAT.MVD_PIXEL_RGB_RGB24_C3 == cMvdImg.PixelFormat)
                {
                    byte bTemp;
                    for (int i = 0; i < nImageWidth * nImageHeight; i++)
                    {
                        bTemp = bBitmapDataTemp[3 * i];
                        bBitmapDataTemp[3 * i] = bBitmapDataTemp[3 * i + 2];
                        bBitmapDataTemp[3 * i + 2] = bTemp;
                    }
                }

                // 考虑图像是否4字节对齐，bitmap要求4字节对齐，而mvdimage不要求对齐
                if (0 == nImageWidth % 4) // 4字节对齐时，直接拷贝
                {
                    Marshal.Copy(bBitmapDataTemp, 0, bitmapData.Scan0, nImageWidth * nImageHeight * nChannelNum);
                }
                else // 按步长逐行拷贝
                {
                    // 每行实际占用字节数
                    Int32 nRowPixelByteNum = nImageWidth * nChannelNum + 4 - (nImageWidth * nChannelNum % 4);
                    // 每行首字节首地址
                    IntPtr bitmapDataRowPos = IntPtr.Zero;
                    for (int i = 0; i < nImageHeight; i++)
                    {
                        // 获取每行第一个像素值的首地址
                        bitmapDataRowPos = new IntPtr(bitmapData.Scan0.ToInt64() + nRowPixelByteNum * i);
                        Marshal.Copy(bBitmapDataTemp, i * nImageWidth * nChannelNum, bitmapDataRowPos, nImageWidth * nChannelNum);
                    }
                }

                cBitmapImg.UnlockBits(bitmapData);
            }
            catch (MvdException ex)
            {
                if (null != cBitmapImg)
                {
                    cBitmapImg.UnlockBits(bitmapData);
                    cBitmapImg.Dispose();
                    cBitmapImg = null;
                }
                throw ex;
            }
            catch (System.Exception ex)
            {
                if (null != cBitmapImg)
                {
                    cBitmapImg.UnlockBits(bitmapData);
                    cBitmapImg.Dispose();
                    cBitmapImg = null;
                }
                throw ex;
            }
        }

    }

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