C#调用Halcon的Hdev文件(脚本化调用)

C#调用Halcon的Hdev文件(脚本化调用)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;

namespace WpfApp1
{
    public class EProcedure
    {
        public string Name { get; set; } = "EProcedure";//函数名称

        //{输入图像,输出图像,输入变量参数,输出变量参数}

        public List<string> IconicInputList = new List<string>();//iconic变量输入 输入图像
        public List<string> IconicOutputList = new List<string>();//iconic变量输出 输出图像

        public List<string> CtrlInputList = new List<string>();//基础变量输入 输入变量参数 
        public List<string> CtrlOutputList = new List<string>();//基础变量输出 输出变量参数 

        public string Body { get; set; } = "";//主要内容

        //添加 HObject变量输入
        public void AddIconInput(string paraName)
        {
            IconicInputList.Add(paraName);
        }

        //添加 HObject输出
        public void AddIconOutput(string paraName)
        {
            IconicOutputList.Add(paraName);
        }

        //添加 Htuple输入
        public void AddCtrlInput(string paraName)
        {
            CtrlInputList.Add(paraName);
        }

        //添加 Htuple输出
        public void AddCtrlOutput(string paraName)
        {
            CtrlOutputList.Add(paraName);
        }

        //获取方面名 类似 add_matrix( : : MatrixAID, MatrixBID : MatrixSumID)
        public string GetProcedureMethod()
        {
            string io = string.Join(",", IconicInputList);
            string oo = string.Join(",", IconicOutputList);
            string ic = string.Join(",", CtrlInputList);
            string oc = string.Join(",", CtrlOutputList);
            string method = $" {Name} ( {io} : {oo} : {ic} : {oc} )";
            return method;
        }

        //获取xml格式
        public static string GetXMLString(List<EProcedure> eProcedureList)
        {

            if (eProcedureList == null)
            {
                return "";
            }
            XmlDocument myXmlDoc = new XmlDocument();
            //<?xml version="1.0" encoding="UTF-8"?>
            myXmlDoc.AppendChild(myXmlDoc.CreateXmlDeclaration("1.0", "UTF-8", null));

            //<hdevelop file_version="1.1" halcon_version="12.0">
            XmlElement hdevelop = myXmlDoc.CreateElement("hdevelop");
            hdevelop.SetAttribute("file_version", "1.1");
            hdevelop.SetAttribute("halcon_version", "12.0");
            myXmlDoc.AppendChild(hdevelop);

            foreach (EProcedure eProcedure in eProcedureList)
            {
                //  <procedure name="detect_fin">
                XmlElement procedure = myXmlDoc.CreateElement("procedure");
                procedure.SetAttribute("name", eProcedure.Name);
                hdevelop.AppendChild(procedure);

                //  <interface>
                XmlElement interfaceNode = myXmlDoc.CreateElement("interface");
                procedure.AppendChild(interfaceNode);

                //参数输入
                //<io> icon输入
                if (eProcedure.IconicInputList.Count > 0)
                {
                    XmlElement io = myXmlDoc.CreateElement("io");
                    foreach (string item in eProcedure.IconicInputList)
                    {
                        XmlElement par = myXmlDoc.CreateElement("par");
                        par.SetAttribute("name", item);
                        par.SetAttribute("base_type", "iconic");
                        par.SetAttribute("dimension", "0");
                        io.AppendChild(par);
                    }
                    interfaceNode.AppendChild(io);
                }

                // oo  icon输出 
                if (eProcedure.IconicOutputList.Count > 0)
                {
                    XmlElement oo = myXmlDoc.CreateElement("oo");
                    foreach (string item in eProcedure.IconicOutputList)
                    {
                        XmlElement par = myXmlDoc.CreateElement("par");
                        par.SetAttribute("name", item);
                        par.SetAttribute("base_type", "iconic");
                        par.SetAttribute("dimension", "0");
                        oo.AppendChild(par);
                    }
                    interfaceNode.AppendChild(oo);
                }
                //ic输入 
                if (eProcedure.CtrlInputList.Count > 0)
                {
                    XmlElement ic = myXmlDoc.CreateElement("ic");
                    foreach (string item in eProcedure.CtrlInputList)
                    {
                        XmlElement par = myXmlDoc.CreateElement("par");
                        par.SetAttribute("name", item);
                        par.SetAttribute("base_type", "ctrl");
                        par.SetAttribute("dimension", "0");
                        ic.AppendChild(par);
                    }
                    interfaceNode.AppendChild(ic);
                }
                // oc输出
                if (eProcedure.CtrlOutputList.Count > 0)
                {
                    XmlElement oc = myXmlDoc.CreateElement("oc");
                    foreach (string item in eProcedure.CtrlOutputList)
                    {
                        XmlElement par = myXmlDoc.CreateElement("par");
                        par.SetAttribute("name", item);
                        par.SetAttribute("base_type", "ctrl");
                        par.SetAttribute("dimension", "0");
                        oc.AppendChild(par);
                    }
                    interfaceNode.AppendChild(oc);
                }

                //body主体
                XmlElement body = myXmlDoc.CreateElement("body");
                procedure.AppendChild(body);

                string[] strArr = eProcedure.Body.Split(new string[] { "\r\n" }, StringSplitOptions.None);
                foreach (string str in strArr)
                {
                    if (str.Trim().StartsWith("*"))
                    {
                        XmlElement line = myXmlDoc.CreateElement("c");//注释
                        line.InnerText = str;
                        body.AppendChild(line);
                    }
                    else
                    {
                        XmlElement line = myXmlDoc.CreateElement("l");//正常行
                        line.InnerText = str;
                        body.AppendChild(line);
                    }
                }
            }

            string xmlStr = "";
            using (StringWriter sw = new StringWriter())
            {
                XmlTextWriter xmlTextWriter = new XmlTextWriter(sw);
                myXmlDoc.WriteTo(xmlTextWriter);
                xmlStr = sw.ToString();
            }
            //  myXmlDoc.Save("detect_fin.hdvp");
            return xmlStr;
        }

        /// <summary>
        /// 返回读取xml里的的EProcedure
        /// </summary>
        /// <param name="path">xml路径</param>
        /// <returns></returns>
        public static List<EProcedure> LoadXmlByFile(string path)
        {

            XmlDocument doc = new XmlDocument();
            doc.Load(path);

            return GetEProcedureList(doc);
        }

        /// <summary>
        /// 根据 xmlstring 得到List<EProcedure> 
        /// </summary>
        /// <param name="xmlString">xml文本</param>
        /// <returns></returns>
        public static List<EProcedure> LoadXmlByString(string xmlString)
        {
            if (string.IsNullOrWhiteSpace(xmlString)) return null;

            XmlDocument doc = new XmlDocument();
            doc.LoadXml(xmlString);

            return GetEProcedureList(doc);
        }

        /// <summary>
        /// 导出hdev
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="eProcedureList">list</param>
        public static void SaveToFile(string fileName, List<EProcedure> eProcedureList)
        {
            FileStream fs = new FileStream(fileName, FileMode.Create);
            StreamWriter sw = new StreamWriter(fs);
            //开始写入
            sw.Write(GetXMLString(eProcedureList));
            //清空缓冲区
            sw.Flush();
            //关闭流
            sw.Close();
            fs.Close();
        }

        /// <summary>
        ///解析xmldocument 获取 List<EProcedure>
        /// </summary>
        /// <param name="doc"></param>
        /// <returns></returns>
        private static List<EProcedure> GetEProcedureList(XmlDocument doc)
        {
            try
            {
                List<EProcedure> eProcedureList = new List<EProcedure>();

                //获取根节点
                XmlNodeList hdevelopList = doc.GetElementsByTagName("hdevelop");

                //获得所有 procedure节点
                XmlNodeList procedureList = hdevelopList[0].ChildNodes;

                //创建对应EProcedure
                foreach (XmlElement procedure in procedureList)
                {
                    EProcedure eProcedure = new EProcedure();

                    //获取名称
                    eProcedure.Name = procedure.GetAttribute("name");

                    //判断interface是否包含子元素
                    XmlNode interface1 = procedure.SelectSingleNode("interface");
                    if (interface1.ChildNodes.Count > 0)
                    {
                        //判断io
                        XmlNode io = interface1.SelectSingleNode("io");
                        if (io != null)
                        {
                            XmlNodeList parList = io.SelectNodes("par");
                            foreach (XmlElement par in parList)
                            {
                                eProcedure.AddIconInput(par.GetAttribute("name"));
                            }
                        }

                        //判断oo
                        XmlNode oo = interface1.SelectSingleNode("oo");
                        if (oo != null)
                        {
                            XmlNodeList parList = oo.SelectNodes("par");
                            foreach (XmlElement par in parList)
                            {
                                eProcedure.AddIconOutput(par.GetAttribute("name"));
                            }
                        }

                        //判断ic
                        XmlNode ic = interface1.SelectSingleNode("ic");
                        if (ic != null)
                        {
                            XmlNodeList parList = ic.SelectNodes("par");
                            foreach (XmlElement par in parList)
                            {
                                eProcedure.AddCtrlInput(par.GetAttribute("name"));
                            }
                        }

                        //判断oc
                        XmlNode oc = interface1.SelectSingleNode("oc");
                        if (oc != null)
                        {
                            XmlNodeList parList = oc.SelectNodes("par");
                            foreach (XmlElement par in parList)
                            {
                                eProcedure.AddCtrlOutput(par.GetAttribute("name"));
                            }
                        }
                    }

                    //获取body
                    XmlNode body = procedure.SelectSingleNode("body");

                    StringBuilder sb = new StringBuilder();
                    foreach (XmlNode line in body.ChildNodes)
                    {
                        sb.Append(line.InnerText + "\r\n");
                    }

                    eProcedure.Body = sb.ToString();
                    eProcedureList.Add(eProcedure);
                }
                return eProcedureList;
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show($"加载脚本文件失败" + ex.ToString());
                return null;
            }
        }

    }
}

界面

<Window x:Class="WpfApp1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApp1"
        mc:Ignorable="d"
                xmlns:halcon="clr-namespace:HalconDotNet;assembly=halcondotnet"

        Title="MainWindow" Height="550" Width="800">
    <Grid>

        <StackPanel>
            <Button Content="选择hdev" HorizontalAlignment="Left" VerticalAlignment="Top" Height="53" Width="147" Click="Button_Click"/>
            <ComboBox Name="CmbRunProcedureMethod" HorizontalAlignment="Left" VerticalAlignment="Top" Width="195" Height="53"/>
            <Button Content="执行函数" HorizontalAlignment="Left" VerticalAlignment="Top" Height="53" Width="147" Click="Button_Click2"/>
            <DataGrid x:Name="dgv1" Height="100" />
            <DataGrid x:Name="dgv2" Height="100" />
            <halcon:HSmartWindowControlWPF x:Name="Hsmart" Height="100"/>

        </StackPanel>
  

    </Grid>
</Window>

using HalconDotNet;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices.ComTypes;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Xml.XPath;
using static System.Net.Mime.MediaTypeNames;

namespace WpfApp1
{

    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {

        HDevProgram program;


        /// <summary>
        /// 图像脚本对象
        /// </summary>
        public List<EProcedure> m_EProcedureList;

        /// <summary>
        /// 输入链接
        /// </summary>
        public List<Inputlink> m_Inputlink = new List<Inputlink>();

        /// <summary>
        /// 输出变量
        /// </summary>
        public List<OutputVar> m_OutputVar = new List<OutputVar>();


        /// <summary>
        /// 调用算子方法
        /// </summary>
        public HDevProcedureCall m_HDevProcedureCall;

        /// <summary>
        /// 执行算子名称
        /// </summary>
        public string RunMethod = string.Empty;

        public MainWindow()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 执行
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click(object sender, RoutedEventArgs e)
        {



            System.Windows.Forms.OpenFileDialog openFile = new System.Windows.Forms.OpenFileDialog();
            openFile.Title = "选择halcon文件";
            openFile.Filter = "halcon文件|*.hdev";
            openFile.FileName = string.Empty;
            openFile.FilterIndex = 1;
            openFile.Multiselect = false;

            if (openFile.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                m_EProcedureList = EProcedure.LoadXmlByFile(openFile.FileName);

                
                CmbRunProcedureMethod.ItemsSource = RunProcedureNameList;
               

            }
            program = new HDevProgram(openFile.FileName);

        }


        /// <summary>
        /// 可用于运行的函数名称列表
        /// </summary>
        private List<string> RunProcedureNameList
        {
            get
            {
                List<string> nameList = new List<string>();
                if (m_EProcedureList != null)
                {
                    foreach (EProcedure item in m_EProcedureList)
                    {
                        //主函数不添加到列表中 
                        if (item.Name != "main")
                        {
                            nameList.Add(item.Name);
                        }
                    }
                }

                return nameList;
            }
        }

        private void Button_Click2(object sender, RoutedEventArgs e)
        {
           

            //加载的方法名称 halcon导出后和文件名称一致 使用哪个算子
            HDevProcedure procedure = new HDevProcedure(program, CmbRunProcedureMethod.Text);

            m_HDevProcedureCall = new HDevProcedureCall(procedure);



            //输入图像参数

            HObject img = new HObject();
            HOperatorSet.ReadImage(out img, @"C:\Users\major\Desktop\Test\1.PNG");
            // 遍历所有图像变量
            for (int i = 0; i < m_EProcedureList[1].IconicInputList.Count; i++)
            {
                m_Inputlink.Add(new Inputlink
                {
                    m_LinkName = m_EProcedureList[1].IconicInputList[i],
                    m_ImageScriptType = ImageScriptType.输入图像参数,

                    // 根据m_LinkName，设置对应的值，可以通过对应连线，或者名称，或者顺序相连接
                    m_Image = img,
                });
            }

            //输入变量参数
            // 遍历所有的参数变量
            for (int i = 0; i < m_EProcedureList[1].CtrlInputList.Count; i++)
            {
                m_Inputlink.Add(new Inputlink
                {
                    m_LinkName = m_EProcedureList[1].CtrlInputList[i],
                    m_ImageScriptType = ImageScriptType.输入变量参数,
 
                    // 根据m_LinkName，设置对应的值，可以通过对应连线，或者名称，或者顺序相连接
                    m_Para = "XXX",
                });
            }

            dgv1.ItemsSource = m_Inputlink;



            m_OutputVar.Clear();
            //输出图像参数
            for (int i = 0; i < m_EProcedureList[1].IconicOutputList.Count; i++)
            {
                m_OutputVar.Add(new OutputVar
                {
                    m_LinkName = m_EProcedureList[1].IconicOutputList[i],
                    m_ImageScriptType = ImageScriptType.输出图像参数,

                    // 根据m_LinkName对输出类型要进行赋值
                    m_DataType = OutDataVarType.图像,
                });
            }

            //输出变量参数
            for (int i = 0; i < m_EProcedureList[1].CtrlOutputList.Count; i++)
            {
                m_OutputVar.Add(new OutputVar
                {
                    m_LinkName = m_EProcedureList[1].CtrlOutputList[i],
                    m_ImageScriptType = ImageScriptType.输出变量参数,
                    // 根据m_LinkName对输出类型要进行赋值
                    m_DataType = OutDataVarType.图像,
                });
            }

            dgv2.ItemsSource = m_OutputVar;



            //输入图像，输入参数
            foreach (Inputlink item in m_Inputlink)
            {
                switch (item.m_ImageScriptType)
                {
                    case ImageScriptType.输入图像参数:


                        m_HDevProcedureCall.SetInputIconicParamObject(item.m_LinkName, item.m_Image);
                        break;
                    case ImageScriptType.输入变量参数:

                        m_HDevProcedureCall.SetInputCtrlParamTuple(item.m_LinkName, new HTuple(Convert.ToInt32(item.m_Para.D)));
                        break;
                    default:
                        break;
                }
            }


            //执行图像脚本
            m_HDevProcedureCall.Execute();


            // 根据输出变量类型，确定Halon-API,获取变量
            foreach (OutputVar item in m_OutputVar)
            {
                switch (item.m_DataType)
                {
                    case OutDataVarType.None:

                        break;
                    case OutDataVarType.Bool:
                        item.m_object = (bool)m_HDevProcedureCall.GetOutputCtrlParamTuple(item.m_LinkName);
                        ;
                        break;
                    case OutDataVarType.Int:
                        item.m_object = (int)m_HDevProcedureCall.GetOutputCtrlParamTuple(item.m_LinkName);

                        break;
                    case OutDataVarType.Double:
                        item.m_object = (double)m_HDevProcedureCall.GetOutputCtrlParamTuple(item.m_LinkName);

                        break;
                    case OutDataVarType.Double数组:
                        item.m_object = (double[])m_HDevProcedureCall.GetOutputCtrlParamTuple(item.m_LinkName);

                        break;
                    case OutDataVarType.String:
                        item.m_object = (string)m_HDevProcedureCall.GetOutputCtrlParamTuple(item.m_LinkName);

                        break;
                    case OutDataVarType.图像:
                        item.m_object = (HImage)m_HDevProcedureCall.GetOutputIconicParamImage(item.m_LinkName);
                        // 清空窗口控件图像 
                        Hsmart.HalconWindow.ClearWindow();
                        // 显示图像
                        Hsmart.HalconWindow.DispObj((HImage)m_HDevProcedureCall.GetOutputIconicParamImage(item.m_LinkName));
                        break;
                    case OutDataVarType.区域:
                        item.m_object = (HRegion)m_HDevProcedureCall.GetOutputIconicParamRegion(item.m_LinkName);

                        break;
                    case OutDataVarType.轮廓:
                        item.m_object = (HXLD)m_HDevProcedureCall.GetOutputIconicParamXld(item.m_LinkName);

                        break;
                    default:
                        break;
                }
            }
        }
    }


    /// <summary>
    /// 输出数据链接
    /// </summary>
    public class Inputlink
    {

        /// <summary>
        /// 链接名称
        /// </summary>
        private string _LinkName;
        public string m_LinkName
        {
            get { return _LinkName; }
            set { _LinkName = value; }
        }




        /// <summary>
        /// 变量类型
        /// </summary>
        private ImageScriptType _ImageScriptType;
        public ImageScriptType m_ImageScriptType
        {
            get { return _ImageScriptType; }
            set { _ImageScriptType = value; }
        }

        // 图像变量
        private HObject _Image;
        public HObject m_Image
        {
            get { return _Image; }
            set { _Image = value; }
        }


        // 参数变量
        // 图像变量
        private HTuple _Para;
        public HTuple m_Para
        {
            get { return _Para; }
            set { _Para = value; }
        }


    }

    /// <summary>
    /// 输出变量
    /// </summary>
    [Serializable]
    public class OutputVar
    {
        /// <summary>
        /// 链接名称
        /// </summary>
        private string _LinkName;
        public string m_LinkName
        {
            get { return _LinkName; }
            set { _LinkName = value; }
        }

        /// <summary>
        /// 数据类型
        /// </summary>
        private OutDataVarType _DataType;
        public OutDataVarType m_DataType
        {
            get { return _DataType; }
            set { _DataType = value; }
        }

        /// <summary>
        /// 变量类型
        /// </summary>
        private ImageScriptType _ImageScriptType;
        public ImageScriptType m_ImageScriptType
        {
            get { return _ImageScriptType; }
            set { _ImageScriptType = value; }
        }

        /// <summary>
        /// 数据结果
        /// </summary>
        [NonSerialized]
        private object _object;
        public object m_object
        {
            get { return _object; }
            set { _object = value; }
        }

    }


    /// <summary>
    /// 图像脚本类型
    /// </summary>

    public enum ImageScriptType
    {
        输入图像参数,
        输入变量参数,
        输出图像参数,
        输出变量参数
    }

    /// <summary>
    /// 变量类型
    /// </summary>

    public enum OutDataVarType
    {
        None,
        Bool,
        Int,
        Double,
        Double数组,
        String,
        图像,
        区域,
        轮廓
    }
}