引言

通过仿照VisionPro软件二次开发Halcon的模板匹配工具，便于在客户端软件中调试，可以保存到本地导入复用，后续开发软件也可快速调用。

前期准备

安装Halcon【教程的版本为19.05】

Step1 设计可序列化的输入输出集合【不支持多线程】

设计可序列化的输入输出集合
1、可通过名称索引，也可以通过序号索引【示例：Inputs[“ABC”]或Inputs[0]】
2、可任意添加和移除【示例：Inputs.Add(“123”,0),Inputs.Remove(0)】

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml.Linq;

namespace MyProcesses.Alogrithms
{
    [Serializable]
    public class AlogrithmCollections<T> : ICollection<AlogrithmCollectionItem<T>>
    {
        private List<AlogrithmCollectionItem<T>> _items = new List<AlogrithmCollectionItem<T>>();

        // 通过名称查找
        public AlogrithmCollectionItem<T> Get(string name)
        {
            var item = _items.FirstOrDefault(item => item.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
            if (item == null)
                return default;
            return item;
        }

        // 通过索引查找
        public AlogrithmCollectionItem<T> Get(int index)
        {
            var item = _items.FirstOrDefault(item => item.Index == index);
            if (item == null)
                return default;
            return item;
        }

        // ICollection<NamedItem<T>> 实现
        public int Count => _items.Count;

        public bool IsReadOnly => false;

        void ICollection<AlogrithmCollectionItem<T>>.Add(AlogrithmCollectionItem<T> item)
        {
            var existingItem = Get(item.Name);

            if (existingItem != null)
            {
                // 如果已存在，更新现有项的值
                existingItem = item;
            }
            else
            {
                // 如果不存在，创建新项并分配索引
                _items.Add(item);
            }

            // 更新后自动排序
            SortItems();
        }
        // 添加项时为新项分配一个索引
        public void Add(string name, T value)
        {
            var existingItem = Get(name);

            if (existingItem != null)
            {
                // 如果已存在，更新现有项的值
                existingItem.Value = value;
            }
            else
            {
                // 如果不存在，创建新项并分配索引
                var newItem = new AlogrithmCollectionItem<T>(name, _items.Count > 0 ? _items.Max(i => i.Index) + 1 : 0, value);
                _items.Add(newItem);
            }

            // 更新后自动排序
            SortItems();
        }
        // 按 Index 排序集合
        private void SortItems()
        {
            _items = _items.OrderBy(item => item.Index).ToList();
        }

        // 通过索引器实现基于序号的访问
        public T this[int index]
        {
            get
            {
                if (index < 0 || index >= _items.Count)
                {
                    return default;
                }
                return _items[index].Value;
            }
            set
            {
                if (index < 0 || index >= _items.Count)
                {
                    return;
                }
                _items[index].Value = value;
            }
        }

        public T this[string name]
        {
            get
            {
                var existingItem = Get(name);
                if (existingItem != null)
                {
                    // 如果已存在，更新现有项的值
                    return existingItem.Value;
                }
                return default;
            }
            set
            {
                var item = _items.FirstOrDefault(i => i.Name == name);
                if (item != null)
                {
                    item.Value = value;
                }
            }
        }

        public void Clear()
        {
            _items.Clear();
            _items.TrimExcess(); // 将容量缩减到实际元素数量
        }

        public bool Contains(AlogrithmCollectionItem<T> item)
        {
            return _items.Contains(item);
        }

        public bool Contains(string name)
        {
            var item = _items.FirstOrDefault(i => i.Name == name);
            if (item != null)
                return true;

            return false;
        }

        public void CopyTo(AlogrithmCollectionItem<T>[] array, int arrayIndex)
        {
            _items.CopyTo(array, arrayIndex);
        }

        public bool Remove(AlogrithmCollectionItem<T> item)
        {
            var removed = _items.Remove(item);
            if (removed)
            {
                // 移除元素后，调整后续元素的索引
                UpdateIndexes();
            }
            return removed;
        }

        public IEnumerator<AlogrithmCollectionItem<T>> GetEnumerator()
        {
            return _items.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _items.GetEnumerator();
        }

        // 通过名称删除
        public bool Remove(string name)
        {
            var namedItem = Get(name);
            if (namedItem != null)
            {
                return Remove(namedItem);
            }
            return false;
        }

        // 通过索引删除
        public bool Remove(int index)
        {
            var namedItem = Get(index);
            if (namedItem != null)
            {
                return Remove(namedItem);
            }
            return false;
        }

        // 删除项后，调整其他项的索引
        private void UpdateIndexes()
        {
            for (int i = 0; i < _items.Count; i++)
            {
                _items[i].Index = i;
            }
        }
    }

    public class AlogrithmCollectionItem<T>
    {
        public string Name { get; set; }
        public int Index { get; set; }
        public T Value { get; set; }       // 存储的对象

        public AlogrithmCollectionItem(string name, int index, T value)
        {
            Name = name;
            Index = index;
            Value = value;
        }

        public override string ToString()
        {
            return $"{Name} (Index: {Index}, Value: {Value})";
        }
    }
}

Step2 设计程序框架

1、抽象层【IProcess】

dicProcesses为可用于实例化的类全称，后续可以通过反射直接实例化该类，这些类都是继承于HAlgorithm

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace MyProcesses
{
    public abstract class IProcess : IDisposable, ICloneable
    {
        /// <summary>
        /// 流程集合
        /// </summary>
        public static Dictionary<string, string> dicProcesses = new Dictionary<string, string>
        {
            { "相机取图", "MyCameras.BaseCamera" },
            { "图片转换工具", "MyProcesses.Alogrithms.Halcon.BitmapConvertToHoImageTool" },
            { "斑点工具", "MyProcesses.Alogrithms.Halcon.HBlobTool" },
            { "模板匹配工具", "MyProcesses.Alogrithms.Halcon.HFindModelTool" },
            { "延时", "MyProcesses.Processes.DelayTime" }
        };

        /// <summary>
        /// 运行日志
        /// </summary>
        public string strMsg = "运行成功";

        /// <summary>
        /// 运行结果
        /// </summary>
        public bool bResult = true;

        /// <summary>
        /// 运行时间
        /// </summary>
        public double RunTime = 0;

        /// <summary>
        /// 允许运行时间
        /// </summary>
        public double MaxTimeOut = 1000;

        /// <summary>
        /// 运行完成标记
        /// </summary>
        protected bool bCompleted = false;

        /// <summary>
        /// 工具名称
        /// </summary>
        public string strProcessName = string.Empty;

        /// <summary>
        /// 工具名称
        /// </summary>
        public string strProcessClass = "MyProcesses.IProcess";

        /// <summary>
        /// 运行参数
        /// </summary>
        public ProcessCollections<object> ProcessCollections = new ProcessCollections<object>();

        public void InitRunParams()
        {
            bResult = false;
            bCompleted = false;
            strMsg = "";
        }

        public abstract bool Run();

        public abstract bool Load(string fullPath);

        public abstract bool Save(string fullPath);

        public static Assembly GetExecutingAssembly()
        {
            return Assembly.GetExecutingAssembly();
        }

        public abstract void Dispose();
        public abstract object Clone();
    }
}

2、父类【HAlgorithm】

父类重载了抽象类的成员函数，后续拓展Halcon算法类只需要继承父类和实例化父类即可

using HalconDotNet;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Collections.Specialized.BitVector32;
using System.Data.Common;
using OpenCvSharp;
using System.Runtime.InteropServices;
using System.Drawing.Imaging;
using System.Drawing;
using Newtonsoft.Json;
using MyControls;
using System.Net;

namespace MyProcesses.Alogrithms.Halcon
{
    public class HAlgorithm : IProcess
    {
        /// <summary>
        /// 输入图片
        /// </summary>
        public object InputImage;

        /// <summary>
        /// 输出图片
        /// </summary>
        public object OutputImage;

        /// <summary>
        /// 运行图片
        /// </summary>
        public HObject hoDomainImage;

        /// <summary>
        /// 结果图片
        /// </summary>
        public HObject hoRecordImage;

        /// <summary>
        /// 算法参数
        /// </summary>
        public AlogrithmParams Params = new AlogrithmParams();

        public bool ReduceDomainImage()
        {
            if (InputImage == null)
            {
                strMsg = "输入图片为空";
                bResult = false;
                return false;
            }

            if (!(InputImage is HObject))
            {
                strMsg = "输入图片不是HObject，未经过转换";
                bResult = false;
                return false;
            }

            lock (InputImage)
            {
                try
                {
                    switch (Params.ROI?.GetType().Name)
                    {
                        case "HRectangle2":
                            HOperatorSet.GenRectangle2(out HObject hRectangle2, (HTuple)((HRectangle2)Params.ROI).Row, (HTuple)((HRectangle2)Params.ROI).Column
                                , (HTuple)((HRectangle2)Params.ROI).Phi, (HTuple)((HRectangle2)Params.ROI).SemiLength1, (HTuple)((HRectangle2)Params.ROI).SemiLength2);
                            HOperatorSet.ReduceDomain((HObject)InputImage, hRectangle2, out hoDomainImage);
                            break;
                        case "HCircle":
                            HOperatorSet.GenCircle(out HObject hCircle, (HTuple)((HCircle)Params.ROI).Row, (HTuple)((HCircle)Params.ROI).Column, (HTuple)((HCircle)Params.ROI).Radius);
                            HOperatorSet.ReduceDomain((HObject)InputImage, hCircle, out hoDomainImage);
                            break;
                        case "ROI":
                        default:
                            hoDomainImage = ((HObject)InputImage)?.CopyObj(1, -1);
                            break;
                    }
                    return true;
                }
                catch
                {
                    strMsg = "裁剪区域失败";
                    bResult = false;
                    return false;
                }
            }
        }

        public override void Dispose()
        {
            if (InputImage != null)
            {
                if (InputImage is HObject)
                    ((HObject)InputImage).Dispose();
            }
            if (hoDomainImage != null)
                hoDomainImage.Dispose();
            if (hoRecordImage != null)
                hoRecordImage.Dispose();

            //this.Dispose();
        }

        public override object Clone()
        {
            return MemberwiseClone();
        }

        public override bool Run()
        {
            DateTime StartTime = DateTime.Now;

            InitRunParams();

            // 创建并启动任务
            Task.Factory.StartNew(() => { HAlgorithmMain(); });

            while ((DateTime.Now - StartTime).TotalMilliseconds <= MaxTimeOut)
            {
                if (bCompleted)
                    return bResult;
            }

            strMsg = "运行超时";
            return false;
        }

        /// <summary>
        /// 算子逻辑
        /// </summary>
        public virtual void HAlgorithmMain()
        {
            bCompleted = true;
            Console.WriteLine("任务完成");
        }

        /// <summary>
        /// 加载算法
        /// </summary>
        /// <param name="fullPath">完整路径带.json</param>
        /// <returns></returns>
        public override bool Load(string fullPath = "")
        {
            try
            {
                if (string.IsNullOrEmpty(fullPath))
                    return false;

                if (!fullPath.Contains(".json"))
                {
                    Console.WriteLine("文件路径不完整");
                    return false;
                }

                if (!File.Exists(fullPath))
                {
                    Console.WriteLine("文件不存在创建空文件");
                    // 获取不带文件名的目录路径
                    string directoryPath = Path.GetDirectoryName(fullPath);
                    strProcessName = Path.GetFileNameWithoutExtension(fullPath);
                    Save(directoryPath);
                    return true;
                }

                string strJson = string.Empty;
                using (StreamReader streamReader = new StreamReader(fullPath, Encoding.UTF8))
                {
                    strJson = streamReader.ReadToEnd();
                    streamReader.Close();
                }
                Params = JsonConvert.DeserializeObject<AlogrithmParams>(strJson);
                if (Params == null)
                    return false;
                return true;
            }
            catch { return false; }
        }

        /// <summary>
        /// 保存算法
        /// </summary>
        /// <param name="filePath">不带.json</param>
        /// <returns></returns>
        public override bool Save(string filePath = "")
        {
            try
            {
                if (string.IsNullOrEmpty(filePath))
                    return false;

                string strJson = string.Empty;
                strJson = JsonConvert.SerializeObject(Params);
                JsonFormatting(ref strJson);
                Params = JsonConvert.DeserializeObject<AlogrithmParams>(strJson);
                //判断文件夹是否存在，防呆输入为文件名称
                if (!Directory.Exists(filePath))
                {
                    try
                    {
                        Directory.CreateDirectory(filePath);
                    }
                    catch (Exception)
                    { }
                }
                File.WriteAllText(filePath + "//" + strProcessName + ".json", strJson, Encoding.UTF8);
                return true;
            }
            catch { return false; }
        }

        #region 自定义的算法
        public static int JsonFormatting(ref string strJson)
        {
            try
            {
                JsonSerializer jsonSerializer = new JsonSerializer();
                JsonReader reader = new JsonTextReader(new StringReader(strJson));
                object obj = jsonSerializer.Deserialize(reader);
                if (obj == null)
                    return 0;
                StringWriter stringWriter = new StringWriter();
                JsonTextWriter jsonTextWriter1 = new JsonTextWriter(stringWriter);
                jsonTextWriter1.Formatting = Formatting.Indented;
                jsonTextWriter1.Indentation = 4;
                jsonTextWriter1.IndentChar = ' ';
                JsonTextWriter jsonTextWriter2 = jsonTextWriter1;
                jsonSerializer.Serialize(jsonTextWriter2, obj);
                strJson = stringWriter.ToString();
                return 1;
            }
            catch (Exception ex)
            {
                return -1;
            }
        }

        public static void Bitmap2HObject(Bitmap bmp, out HObject image)
        {
            try
            {
                if (bmp == null)
                {
                    image = null;
                    return;
                }
                BitmapData srcBmpData;
                switch (bmp.PixelFormat)
                {
                    case PixelFormat.Format24bppRgb:
                        srcBmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
                        HOperatorSet.GenImageInterleaved(out image, srcBmpData.Scan0, "bgr", bmp.Width, bmp.Height, 0, "byte", 0, 0, 0, 0, -1, 0);
                        bmp.UnlockBits(srcBmpData);
                        break;
                    default:
                        srcBmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format8bppIndexed);

                        HOperatorSet.GenImage1(out image, "byte", bmp.Width, bmp.Height, srcBmpData.Scan0);
                        bmp.UnlockBits(srcBmpData);
                        break;
                }
            }
            catch (Exception ex)
            {
                image = null;
            }
        }

        /// <summary>
        /// 显示符号
        /// </summary>
        /// <param name="hv_WindowHandle"></param>
        /// <param name="hv_String"></param>
        /// <param name="hv_CoordSystem"></param>
        /// <param name="hv_Row"></param>
        /// <param name="hv_Column"></param>
        /// <param name="hv_Color"></param>
        /// <param name="hv_Box"></param>
        public static void disp_message(HTuple hv_WindowHandle, HTuple hv_String, HTuple hv_CoordSystem, HTuple hv_Row, HTuple hv_Column, HTuple hv_Color, HTuple hv_Box)
        {
            // Local iconic variables 

            // Local control variables 

            HTuple hv_GenParamName = new HTuple(), hv_GenParamValue = new HTuple();
            HTuple hv_Color_COPY_INP_TMP = new HTuple(hv_Color);
            HTuple hv_Column_COPY_INP_TMP = new HTuple(hv_Column);
            HTuple hv_CoordSystem_COPY_INP_TMP = new HTuple(hv_CoordSystem);
            HTuple hv_Row_COPY_INP_TMP = new HTuple(hv_Row);

            try
            {
                if ((int)new HTuple(hv_Row_COPY_INP_TMP.TupleEqual(new HTuple())).TupleOr(
                    new HTuple(hv_Column_COPY_INP_TMP.TupleEqual(new HTuple()))) != 0)
                {

                    hv_Color_COPY_INP_TMP.Dispose();
                    hv_Column_COPY_INP_TMP.Dispose();
                    hv_CoordSystem_COPY_INP_TMP.Dispose();
                    hv_Row_COPY_INP_TMP.Dispose();
                    hv_GenParamName.Dispose();
                    hv_GenParamValue.Dispose();

                    return;
                }
                if ((int)new HTuple(hv_Row_COPY_INP_TMP.TupleEqual(-1)) != 0)
                {
                    hv_Row_COPY_INP_TMP.Dispose();
                    hv_Row_COPY_INP_TMP = 12;
                }
                if ((int)new HTuple(hv_Column_COPY_INP_TMP.TupleEqual(-1)) != 0)
                {
                    hv_Column_COPY_INP_TMP.Dispose();
                    hv_Column_COPY_INP_TMP = 12;
                }
                //
                //Convert the parameter Box to generic parameters.
                hv_GenParamName.Dispose();
                hv_GenParamName = new HTuple();
                hv_GenParamValue.Dispose();
                hv_GenParamValue = new HTuple();
                if ((int)new HTuple(new HTuple(hv_Box.TupleLength()).TupleGreater(0)) != 0)
                {
                    if ((int)new HTuple(hv_Box.TupleSelect(0).TupleEqual("false")) != 0)
                    {
                        //Display no box
                        using (HDevDisposeHelper dh = new HDevDisposeHelper())
                        {
                            {
                                HTuple
                                  ExpTmpLocalVar_GenParamName = hv_GenParamName.TupleConcat(
                                    "box");
                                hv_GenParamName.Dispose();
                                hv_GenParamName = ExpTmpLocalVar_GenParamName;
                            }
                        }
                        using (HDevDisposeHelper dh = new HDevDisposeHelper())
                        {
                            {
                                HTuple
                                  ExpTmpLocalVar_GenParamValue = hv_GenParamValue.TupleConcat(
                                    "false");
                                hv_GenParamValue.Dispose();
                                hv_GenParamValue = ExpTmpLocalVar_GenParamValue;
                            }
                        }
                    }
                    else if ((int)new HTuple(hv_Box.TupleSelect(0).TupleNotEqual(
                        "true")) != 0)
                    {
                        //Set a color other than the default.
                        using (HDevDisposeHelper dh = new HDevDisposeHelper())
                        {
                            {
                                HTuple
                                  ExpTmpLocalVar_GenParamName = hv_GenParamName.TupleConcat(
                                    "box_color");
                                hv_GenParamName.Dispose();
                                hv_GenParamName = ExpTmpLocalVar_GenParamName;
                            }
                        }
                        using (HDevDisposeHelper dh = new HDevDisposeHelper())
                        {
                            {
                                HTuple
                                  ExpTmpLocalVar_GenParamValue = hv_GenParamValue.TupleConcat(
                                    hv_Box.TupleSelect(0));
                                hv_GenParamValue.Dispose();
                                hv_GenParamValue = ExpTmpLocalVar_GenParamValue;
                            }
                        }
                    }
                }
                if ((int)new HTuple(new HTuple(hv_Box.TupleLength()).TupleGreater(1)) != 0)
                {
                    if ((int)new HTuple(hv_Box.TupleSelect(1).TupleEqual("false")) != 0)
                    {
                        //Display no shadow.
                        using (HDevDisposeHelper dh = new HDevDisposeHelper())
                        {
                            {
                                HTuple
                                  ExpTmpLocalVar_GenParamName = hv_GenParamName.TupleConcat(
                                    "shadow");
                                hv_GenParamName.Dispose();
                                hv_GenParamName = ExpTmpLocalVar_GenParamName;
                            }
                        }
                        using (HDevDisposeHelper dh = new HDevDisposeHelper())
                        {
                            {
                                HTuple
                                  ExpTmpLocalVar_GenParamValue = hv_GenParamValue.TupleConcat(
                                    "false");
                                hv_GenParamValue.Dispose();
                                hv_GenParamValue = ExpTmpLocalVar_GenParamValue;
                            }
                        }
                    }
                    else if ((int)new HTuple(hv_Box.TupleSelect(1).TupleNotEqual(
                        "true")) != 0)
                    {
                        //Set a shadow color other than the default.
                        using (HDevDisposeHelper dh = new HDevDisposeHelper())
                        {
                            {
                                HTuple
                                  ExpTmpLocalVar_GenParamName = hv_GenParamName.TupleConcat(
                                    "shadow_color");
                                hv_GenParamName.Dispose();
                                hv_GenParamName = ExpTmpLocalVar_GenParamName;
                            }
                        }
                        using (HDevDisposeHelper dh = new HDevDisposeHelper())
                        {
                            {
                                HTuple
                                  ExpTmpLocalVar_GenParamValue = hv_GenParamValue.TupleConcat(
                                    hv_Box.TupleSelect(1));
                                hv_GenParamValue.Dispose();
                                hv_GenParamValue = ExpTmpLocalVar_GenParamValue;
                            }
                        }
                    }
                }
                //Restore default CoordSystem behavior.
                if ((int)new HTuple(hv_CoordSystem_COPY_INP_TMP.TupleNotEqual("window")) != 0)
                {
                    hv_CoordSystem_COPY_INP_TMP.Dispose();
                    hv_CoordSystem_COPY_INP_TMP = "image";
                }
                //
                if ((int)new HTuple(hv_Color_COPY_INP_TMP.TupleEqual("")) != 0)
                {
                    //disp_text does not accept an empty string for Color.
                    hv_Color_COPY_INP_TMP.Dispose();
                    hv_Color_COPY_INP_TMP = new HTuple();
                }
                //
                //HOperatorSet.DispText(hv_WindowHandle, hv_String, hv_CoordSystem_COPY_INP_TMP,
                //    hv_Row_COPY_INP_TMP, hv_Column_COPY_INP_TMP, hv_Color_COPY_INP_TMP, hv_GenParamName,hv_GenParamValue);
                HOperatorSet.SetTposition(hv_WindowHandle, hv_Row_COPY_INP_TMP, hv_Column_COPY_INP_TMP);
                HOperatorSet.WriteString(hv_WindowHandle, hv_String);
                hv_Color_COPY_INP_TMP.Dispose();
                hv_Column_COPY_INP_TMP.Dispose();
                hv_CoordSystem_COPY_INP_TMP.Dispose();
                hv_Row_COPY_INP_TMP.Dispose();
                hv_GenParamName.Dispose();
                hv_GenParamValue.Dispose();

                return;
            }
            catch (HalconException HDevExpDefaultException)
            {

                hv_Color_COPY_INP_TMP.Dispose();
                hv_Column_COPY_INP_TMP.Dispose();
                hv_CoordSystem_COPY_INP_TMP.Dispose();
                hv_Row_COPY_INP_TMP.Dispose();
                hv_GenParamName.Dispose();
                hv_GenParamValue.Dispose();

                throw HDevExpDefaultException;
            }
        }

        public static void SetColor(HTuple hv_WindowHandle)
        {
            HOperatorSet.SetColor(hv_WindowHandle, GetRandomColor());
        }

        /// <summary>
        /// 设置颜色("dark olive green")
        /// </summary>
        /// <param name="hv_WindowHandle"></param>
        /// <param name="color"></param>
        public static void SetColor(HTuple hv_WindowHandle, string color)
        {
            HOperatorSet.SetColor(hv_WindowHandle, color);
        }

        /// <summary>
        /// 生成Halcon随机颜色
        /// </summary>
        /// <returns></returns>
        public static string GetRandomColor()
        {
            // 获取当前时间的毫秒数作为种子
            int seed = DateTime.Now.Millisecond;

            // 使用种子创建 Random 实例
            Random random = new Random(seed);

            // 生成随机数
            int randomNumber = random.Next(0, 18);

            // 延时随机时间变更随机种子
            Thread.Sleep(randomNumber);

            string[] strsColors = new string[]
            {
                "red", "green","blue", "cyan", "magenta",
                "yellow", "dim gray", "gray","light gray", "medium slate blue", "coral", "slate blue",
                "spring green", "orange red", "orange", "dark olive green","pink", "forest green", "cadet blue"
            };
            if (randomNumber <= strsColors.Length)
                return strsColors[randomNumber];
            else
                return strsColors[0];
        }
        /// <summary>
        /// 计算两点的距离
        /// </summary>
        /// <param name="startPoint"></param>
        /// <param name="endPoint"></param>
        /// <returns></returns>
        public static double GetDistanceP2P(HPoint startPoint, HPoint endPoint)
        {
            try
            {
                return Math.Sqrt(Math.Pow(startPoint.X - endPoint.X, 2) + Math.Pow(startPoint.Y - endPoint.Y, 2));
            }
            catch { return 9994; }
        }
        public static double GetDistanceP2P(System.Drawing.Point startPoint, System.Drawing.Point endPoint)
        {
            return GetDistanceP2P(new HPoint(startPoint), new HPoint(endPoint));
        }
        public static double DistanceP2P(double startX, double startY, double endX, double endY)
        {
            return GetDistanceP2P(new HPoint(startX, startY), new HPoint(endX, endY));
        }

        /// <summary>
        /// 获取两点的中点
        /// </summary>
        /// <param name="startPoint"></param>
        /// <param name="endPoint"></param>
        /// <returns></returns>
        public static HPoint GetMidPoint(HPoint startPoint, HPoint endPoint)
        {
            return new HPoint((startPoint.X + endPoint.X) / 2, (startPoint.Y + endPoint.Y) / 2);
        }
        public static OpenCvSharp.Point GetMidPoint(OpenCvSharp.Point startPoint, OpenCvSharp.Point endPoint)
        {
            return new OpenCvSharp.Point((startPoint.X + endPoint.X) / 2, (startPoint.Y + endPoint.Y) / 2);
        }

        /// <summary>
        /// 判断点是否在线段上
        /// </summary>
        /// <param name="point"></param>
        /// <param name="segment"></param>
        /// <returns></returns>
        public static bool IsPointOnSegment(HPoint pt, HSegment segment, double tolerance = 1e-3)
        {
            // 计算直线方程的系数
            double A = segment.EndY - segment.StartX;
            double B = segment.StartX - segment.EndX;
            double C = segment.EndX * segment.StartY - segment.StartX * segment.EndY;

            // 计算点到直线的距离
            double distance = Math.Abs(A * pt.X + B * pt.Y + C) / Math.Sqrt(A * A + B * B);

            // 允许一个很小的误差
            if (distance < tolerance)
            {
                // 判断点是否在直线段范围内
                if (Math.Min(segment.StartX, segment.EndX) <= pt.X && pt.X <= Math.Max(segment.StartX, segment.EndX)
                 && Math.Min(segment.StartY, segment.EndY) <= pt.Y && pt.Y <= Math.Max(segment.StartY, segment.EndY))
                {
                    return true;
                }
            }
            return false;
        }
        public static bool IsPointOnSegment(double px, double py, double x1, double y1, double x2, double y2)
        {
            return IsPointOnSegment(new HPoint(px, py), new HSegment(x1, y1, x2, y2));
        }

        /// <summary>
        /// 判断点是否在矩形边附近
        /// </summary>
        /// <param name="pt"></param>
        /// <param name="rect"></param>
        /// <param name="tolerance"></param>
        /// <returns></returns>
        static bool IsPointNearRectangleSilde(OpenCvSharp.Point pt, Rectangle rect, double tolerance = 100)
        {
            try
            {
                // 如果点的 X 坐标等于矩形的左边 (rect.Left) 或右边 (rect.Right)，并且 Y 坐标在矩形的上下边界之间，那么点在矩形的垂直边界上。
                // 如果点的 Y 坐标等于矩形的上边(rect.Top) 或下边(rect.Bottom)，并且 X 坐标在矩形的左右边界之间，那么点在矩形的水平边界上。
                return (Math.Abs(pt.X - rect.Left) <= tolerance || Math.Abs(pt.X - rect.Right) <= tolerance) && pt.Y >= rect.Top + tolerance && pt.Y <= rect.Bottom - tolerance
                    || (Math.Abs(pt.Y - rect.Top) <= tolerance || Math.Abs(pt.Y - rect.Bottom) <= tolerance) && pt.X >= rect.Left - tolerance && pt.X <= rect.Right + tolerance;

            }
            catch { return false; }
        }
        public static bool IsPointNearRectangleSilde(HPoint pt, HRectangle2 rect, double tolerance = 100)
        {
            return IsPointNearRectangleSilde(new OpenCvSharp.Point((int)pt.X, (int)pt.Y), new Rectangle((int)rect.CenterX, (int)rect.CenterY, (int)rect.Width, (int)rect.Height), tolerance);
        }

        /// <summary>
        /// 判断点是否在点附近
        /// </summary>
        /// <param name="pt1"></param>
        /// <param name="pt2"></param>
        /// <param name="tolerance"></param>
        /// <returns></returns>
        public static bool IsPointNearPoint(HPoint pt1, HPoint pt2, double tolerance = 100)
        {
            if (GetDistanceP2P(pt1, pt2) <= tolerance)
                return true;
            return false;
        }

        public static bool IsPointNearPoint(System.Drawing.Point pt1, System.Drawing.Point pt2, double tolerance = 100)
        {
            if (GetDistanceP2P(pt1, pt2) <= tolerance)
                return true;
            return false;
        }
        public static bool IsPointNearPoint(double x1, double y1, double x2, double y2, int tolerance = 100)
        {
            return IsPointNearPoint(new HPoint(x1, y1), new HPoint(x2, y2), tolerance);
        }

        /// <summary>
        /// 判断点是否在矩形角上
        /// </summary>
        /// <param name="pt"></param>
        /// <param name="rect"></param>
        /// <param name="corner"></param>
        /// <param name="tolerance"></param>
        /// <returns></returns>
        public static bool IsPointNearRectangleCorner(System.Drawing.Point pt, Rectangle rect, out string corner, double tolerance = 10)
        {
            try
            {
                //按顺时针去匹配角位
                System.Drawing.Point LeftTopPoint = new System.Drawing.Point(rect.Left, rect.Top);
                if (IsPointNearPoint(LeftTopPoint, pt, tolerance))
                {
                    corner = "LeftTop";
                    return true;
                }

                System.Drawing.Point RightTopPoint = new System.Drawing.Point(rect.Right, rect.Top);
                if (IsPointNearPoint(RightTopPoint, pt, tolerance))
                {
                    corner = "RightTop";
                    return true;
                }

                System.Drawing.Point RightBtmPoint = new System.Drawing.Point(rect.Right, rect.Bottom);
                if (IsPointNearPoint(RightBtmPoint, pt, tolerance))
                {
                    corner = "RightBtm";
                    return true;
                }

                System.Drawing.Point LeftBtmPoint = new System.Drawing.Point(rect.Left, rect.Bottom);
                if (IsPointNearPoint(LeftBtmPoint, pt, tolerance))
                {
                    corner = "LeftBtm";
                    return true;
                }

                corner = "";
                return false;
            }
            catch { corner = ""; return false; }
        }
        public static bool IsPointNearRectangleCorner(HPoint pt, HRectangle2 rect, out string corner, double tolerance = 10)
        {
            try
            {
                //按顺时针去匹配角位
                var rectCorners = rect.Corners;
                HPoint LeftTopPoint = rectCorners[0];
                if (IsPointNearPoint(LeftTopPoint, pt, tolerance))
                {
                    corner = "LeftTop";
                    return true;
                }

                HPoint RightTopPoint = rectCorners[1];
                if (IsPointNearPoint(RightTopPoint, pt, tolerance))
                {
                    corner = "RightTop";
                    return true;
                }

                HPoint RightBtmPoint = rectCorners[2];
                if (IsPointNearPoint(RightBtmPoint, pt, tolerance))
                {
                    corner = "RightBtm";
                    return true;
                }

                HPoint LeftBtmPoint = rectCorners[3];
                if (IsPointNearPoint(LeftBtmPoint, pt, tolerance))
                {
                    corner = "LeftBtm";
                    return true;
                }

                corner = "";
                return false;
            }
            catch { corner = ""; return false; }
        }
        #endregion
    }
}

3、子类【HFindModelTool】

后续只需要通过CreateModel,Save,Load,Run等封装好的函数既可以运行模板匹配工具

using HalconDotNet;
using MyProcesses.Alogrithms.Halcon;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.ToolTip;

namespace MyProcesses.Alogrithms.Halcon
{
    public class HFindModelTool : HAlgorithm
    {
        public HModel ModelID = new HModel();

        public HFindModelTool()
        {
            strProcessClass = "MyProcesses.Alogrithms.Halcon.HFindModelTool";
			strProcessName = "模板匹配工具";
			
            //ModelType：模板类型
            Params.Inputs.Add("ModelType", "形状");
            //AngleStart：搜索时的起始角度【需要转换为弧度】
            Params.Inputs.Add("AngleStart", -5.0);
            //AngleExtent：搜索时的角度范围,0表示无角度搜索【需要转换为弧度】
            Params.Inputs.Add("AngleExtent", 10.0);
            //AngleStep：角度步长--弧度【角度步长 >= 0和角度步长 <= pi / 16】
            Params.Inputs.Add("AngleStep", "auto");
            Params.Inputs.Add("ScaleRMin", 0.9);
            Params.Inputs.Add("ScaleRMax", 1.1);
            Params.Inputs.Add("ScaleCMin", 0.9);
            Params.Inputs.Add("ScaleCMax", 1.1);
            //MinScore：被找到的模板最小分数
            Params.Inputs.Add("MinScore", 0.5);
            //NumMatches：要找到的模板最多的实例数,0则找到所有可能的匹配
            Params.Inputs.Add("NumMatches", 0);
            //MaxOverlap：允许找到的模型实例的最大重叠比例, 建议值：0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0
            Params.Inputs.Add("MaxOverlap", 0.2);
            //SubPixel：计算精度的设置
            //'none'    不适用亚像素,最大误差为半个像素
            //'interpolation'   差值得到亚像素精度
            //'least_squares', 'least_squares_high', 'least_squares_very_high'
            //'max_deformation 1', 'max_deformation 2', 'max_deformation 3', 'max_deformation 4'
            Params.Inputs.Add("SubPixel", "none");
            //NumLevels：搜索时金字塔的层级,0表示不使用金字塔
            Params.Inputs.Add("NumLevels", 0);
            //Greediness：贪婪度,搜索启发式,一般都设为0.8,越高速度快,容易出现找不到的情况
            Params.Inputs.Add("Greediness", 0.8);
            Params.Inputs.Add("ResultType", 1);
            //Params.Inputs.Add("GenParamName", new HTuple());
            //Params.Inputs.Add("GenParamValue", new HTuple());
            Params.Inputs.Add("MinCount", 0);
            Params.Inputs.Add("MaxCount", 9999);

            Params.Outputs.Add("CenterX", new List<double>());
            Params.Outputs.Add("CenterY", new List<double>());
            Params.Outputs.Add("Angle", new List<double>());
            Params.Outputs.Add("Score", new List<double>());
            Params.Outputs.Add("Count", 0);
        }

        /// <summary>
        /// 运行算子
        /// </summary>
        public override void HAlgorithmMain()
        {
            #region 初始化变量
            HTuple hv_CenterRow = new HTuple();
            HTuple hv_CenterColumn = new HTuple();
            HTuple hv_CenterPhi = new HTuple();
            HTuple hv_Score = new HTuple();
            //创建虚拟HWindow用于显示图片【需要释放】
            HWindowControl hWindowControl = new HWindowControl();
            #endregion

            try
            {
                if (InputImage == null)
                {
                    strMsg = "输入图片为空";
                    bResult = false;
                    return;
                }

                #region 裁剪区域
                if (!ReduceDomainImage())
                {
                    strMsg = "裁剪区域失败";
                    bResult = false;
                    return;
                }
                #endregion

                //判断是否有模板
                if (ModelID.hvModel == null || ModelID.hvModel.Length == 0)
                {
                    strMsg = "未创建模板";
                    bResult = false;
                    return;
                }

                #region 算子逻辑
                HOperatorSet.Rgb1ToGray(hoDomainImage, out hoDomainImage);
                //判断是否为灰度图
                using (HDevDisposeHelper dh = new HDevDisposeHelper())
                {
                    HOperatorSet.CountChannels(hoDomainImage, out HTuple hv_Channels);
                    if (hv_Channels.TupleInt() != 1)
                    {
                        strMsg = "输入图片不为灰度图";
                        bResult = false;
                        return;
                    }
                }

                string type = ModelID.Type.ToString();
                double AngleStart = (double)Params.Inputs["AngleStart"];
                double AngleExtent = (double)Params.Inputs["AngleExtent"];
                double MinScore = (double)Params.Inputs["MinScore"];
                int NumMatches = AlogrithmParams.ConvertToInt32(Params.Inputs["NumMatches"]);
                double MaxOverlap = (double)Params.Inputs["MaxOverlap"];
                string SubPixel = AlogrithmParams.ConvertToString(Params.Inputs["SubPixel"]);
                int NumLevels = AlogrithmParams.ConvertToInt32(Params.Inputs["NumLevels"]);
                double Greediness = (double)Params.Inputs["Greediness"];

                switch (type)
                {
                    case "ShapeModel":
                        //形状模板匹配
                        #region 参数介绍
                        //* 参数1：输入图像
                        //* 参数2：模板句柄
                        //* 参数3：搜索时的起始角度
                        //* 参数4：搜索时的终止角度,必须与创建模板时的有交集
                        //* 参数5:被找到的模板最小分数--大于等于这个值才能被匹配
                        //* 默认值：0.5      建议值：0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0
                        //* 典型值范围：0≤MinScore ≤ 1
                        //* 最小增量：0.01       建议增量：0.05
                        //* 参数6：要找到的模板最大实例数
                        //* 0   不限制
                        //* 参数7：要找到的模型实例的最大重叠比例
                        //* 默认值：0.5       建议值：0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0
                        //* 典型值范围：0≤ MaxOverlap≤ 1      最小增量：0.01     建议增量：0.05
                        //* 0 表示不允许重叠
                        //* 参数8：计算精度的设置
                        //* 'none'   不适用亚像素,最大误差为半个像素
                        //* 'interpolation'   差值得到亚像素精度
                        //* 'least_squares', 'least_squares_high', 'least_squares_very_high'
                        //* 'max_deformation 1', 'max_deformation 2', 'max_deformation 3', 'max_deformation 4'
                        //* 'max_deformation 5', 'max_deformation 6'
                        //* 参数9：搜索时金字塔的层级
                        //* 参数10：贪婪度,搜索启发式,一般都设为0.8,越高速度快,容易出现找不到的情况
                        //* 0≤ Greediness ≤ 1
                        //* 最后4个：输出匹配位置的行和列坐标、角度、得分 【中心坐标】
                        #endregion
                        HOperatorSet.FindShapeModel(hoDomainImage, ModelID.hvModel
                            , (HTuple)(AngleStart / 180.0 * Math.PI)
                            , (HTuple)(AngleExtent / 180.0 * Math.PI)
                            , (HTuple)MinScore
                            , (HTuple)NumMatches
                            , (HTuple)MaxOverlap
                            , (HTuple)SubPixel
                            , (HTuple)NumLevels
                            , (HTuple)Greediness
                            , out hv_CenterRow, out hv_CenterColumn
                            , out hv_CenterPhi, out hv_Score);
                        break;
                    case "LocalDeformableModel":
                        break;
                    default:
                        strMsg = "未创建模板";
                        bResult = false;
                        return;
                }
                #endregion

                #region 结果处理
                OutputImage = hoDomainImage;
                List<double> CenterX = new List<double>();
                List<double> CenterY = new List<double>();
                List<double> Angle = new List<double>();
                List<double> Score = new List<double>();
                for (int i = 0; i < hv_CenterRow.Length; i++)
                {
                    CenterX.Add(Math.Round(hv_CenterColumn[i].D, 3));
                    CenterY.Add(Math.Round(hv_CenterRow[i].D, 3));
                    Angle.Add(Math.Round(hv_CenterPhi[i].D / Math.PI * 180, 3));
                    Score.Add(Math.Round(hv_Score[i].D, 3));
                }

                Params.Outputs["CenterX"] = CenterX;
                Params.Outputs["CenterY"] = CenterY;
                Params.Outputs["Angle"] = Angle;
                Params.Outputs["Score"] = Score;
                Params.Outputs["Count"] = CenterX.Count;
                #endregion

                #region 生成RecordImage便于分析和显示
                HOperatorSet.GetImageSize(hoDomainImage, out HTuple ho_ImageWidth, out HTuple ho_ImageHeight);
                HOperatorSet.SetPart(hWindowControl.HalconWindow, 0, 0, ho_ImageHeight - 1, ho_ImageWidth - 1);

                HOperatorSet.ClearWindow(hWindowControl.HalconWindow);
                HOperatorSet.DispObj(hoDomainImage, hWindowControl.HalconWindow);

                for (int i = 0; i < hv_CenterRow.Length; i++)
                {
                    SetColor(hWindowControl.HalconWindow, "dark olive green");
                    HOperatorSet.GenCrossContourXld(out HObject hCross, hv_CenterRow[i].D, hv_CenterColumn[i].D, 300, 0);
                    HOperatorSet.DispObj(hCross, hWindowControl.HalconWindow);

                    //HOperatorSet.GenCircle(out HObject hPoint, hv_CenterRow[i].D, hv_CenterColumn[i].D, 30);
                    //HOperatorSet.DispObj(hPoint, hWindowControl.HalconWindow);
                }

                //生成RecordImage
                try
                {
                    HOperatorSet.DumpWindowImage(out hoRecordImage, hWindowControl.HalconWindow);
                }
                catch (Exception ex)
                {
                    strMsg = "生成RecordImage失败,原因是:" + ex.ToString();
                    bResult = false;
                    return;
                }
                #endregion

                if (strMsg == "运行超时")
                {
                    bResult = false;
                    return;
                }

                int MinCount = AlogrithmParams.ConvertToInt32(Params.Inputs["MinCount"]);
                int MaxCount = AlogrithmParams.ConvertToInt32(Params.Inputs["MaxCount"]);

                if (CenterX.Count < MinCount || CenterX.Count > MaxCount)
                {
                    strMsg = string.Format("结果个数超出范围({0},{1})", MinCount, MaxCount);
                    bResult = false;
                    return;
                }

                strMsg = "运行成功";
                bResult = true;
                return;
            }
            catch (Exception ex)
            {
                strMsg = "运行失败,原因是:" + ex.ToString().TrimEnd();
                HOperatorSet.GenEmptyObj(out hoRecordImage);
                bResult = false;
                return;
            }
            finally
            {
                bCompleted = true;
                #region 内存释放
                hWindowControl.Dispose();
                hoDomainImage.Dispose();
                #endregion
            }
        }

        public bool CreateModel(HObject Template, HTuple NumLevels, HTuple AngleStart, HTuple AngleExtent, HTuple AngleStep
            , HTuple Optimization, HTuple Metric, HTuple Contrast, HTuple MinContrast, ModelType modelType)
        {
            try
            {
                switch (modelType)
                {
                    case ModelType.ShapeModel:
                        //形状模板匹配
                        #region 参数介绍
                        //Template: : //reduce_domain后的模板图像
                        //NumLevels ,//金字塔的层数，可设为“auto”或0—10的整数
                        //AngleStart ,//模板旋转的起始角度
                        //AngleExtent ,//模板旋转角度范围, >=0
                        //AngleStep ,//旋转角度的步长， >=0 and <=pi/16
                        //Optimization ,//设置模板优化和模板创建方法
                        //Metric , //匹配方法设置
                        //Contrast ,//设置对比度
                        //MinContrast // 设置最小对比度
                        #endregion
                        HOperatorSet.CreateShapeModel(Template, NumLevels, AngleStart, AngleExtent, AngleStep, Optimization, Metric, Contrast, MinContrast, out ModelID.hvModel);
                        ModelID.hoImage = Template.CopyObj(1, -1);
                        return true;
                    case ModelType.LocalDeformableModel:
                    default:
                        return false;
                }
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 加载算法
        /// </summary>
        /// <param name="fullPath">完整路径带.json</param>
        /// <returns></returns>
        public override bool Load(string fullPath)
        {
            try
            {
                if (string.IsNullOrEmpty(fullPath))
                    return false;

                if (!fullPath.Contains(".json"))
                {
                    Console.WriteLine("文件路径不完整");
                    return false;
                }

                if (fullPath.StartsWith(".\\"))
                {
                    // 判断原字符串长度是否大于等于2，避免越界
                    if (fullPath.Length >= 2)
                    {
                        // 替换开头两个字符
                        fullPath = Application.StartupPath + fullPath.Substring(2);
                        Console.WriteLine($"修改后的字符串: {fullPath}");
                    }
                }

                if (!File.Exists(fullPath))
                {
                    Console.WriteLine("文件不存在创建空文件");
                    // 获取不带文件名的目录路径
                    string directoryPath = Path.GetDirectoryName(fullPath);
                    strProcessName = Path.GetFileNameWithoutExtension(fullPath);
                    ModelID = new HModel(fullPath, ModelType.ShapeModel);
                    Save(directoryPath);
                    ModelID.Save(fullPath, ModelID.Type);
                    return true;
                }
                string strJson = string.Empty;
                using (StreamReader streamReader = new StreamReader(fullPath, Encoding.UTF8))
                {
                    strJson = streamReader.ReadToEnd();
                    streamReader.Close();
                }
                Params = JsonConvert.DeserializeObject<AlogrithmParams>(strJson);
                if (Params == null)
                    return false;
                if (!ModelID.Load(fullPath, Params.Inputs["ModelType"].ToString()))
                    return false;
                return true;
            }
            catch { return false; }
        }

        /// <summary>
        /// 保存算法
        /// </summary>
        /// <param name="filePath">不带.json</param>
        /// <returns></returns>
        public override bool Save(string filePath)
        {
            try
            {
                base.Save(filePath);
                //if (string.IsNullOrEmpty(filePath))
                //    return false;

                //string strJson = string.Empty;
                //strJson = JsonConvert.SerializeObject(Params);
                //JsonFormatting(ref strJson);
                判断文件夹是否存在，防呆输入为文件名称
                //if (!Directory.Exists(filePath))
                //{
                //    try
                //    {
                //        Directory.CreateDirectory(filePath);
                //    }
                //    catch (Exception)
                //    { }
                //}
                //File.WriteAllText(filePath + "//" + strProcessName + ".json", strJson, Encoding.UTF8);
                ModelID.Save(filePath + "//" + strProcessName + ".json", ModelID.Type);
                return true;
            }
            catch { return false; }
        }
    }

    public enum ModelType { None, ShapeModel, LocalDeformableModel };

    public class HModel
    {
        public HModel(string modelName = "") { ModelName = modelName; }

        public HModel(string modelFullPath, string modelType)
        {
            ModelFullPath = modelFullPath;
            switch (modelType)
            {
                case "形状":
                    Type = ModelType.ShapeModel; break;
                case "可形变":
                    Type = ModelType.LocalDeformableModel; break;
                default:
                    Type = ModelType.None; break;
            }
            Load(ModelFullPath, modelType);
        }

        public HModel(string modelFullPath, ModelType modelType)
        {
            ModelFullPath = modelFullPath;
            switch (modelType)
            {
                case ModelType.ShapeModel:
                    Type = ModelType.ShapeModel;
                    Load(ModelFullPath, "形状");
                    break;
                case ModelType.LocalDeformableModel:
                    Type = ModelType.LocalDeformableModel;
                    Load(ModelFullPath, "可形变");
                    break;
                default:
                    Type = ModelType.None; break;
            }
        }

        /// <summary>
        /// 模板路径
        /// </summary>
        public string ModelFullPath = "C:\\MyVisionModel\\ModelName.none";

        /// <summary>
        /// 模板名称
        /// </summary>
        public string ModelName = string.Empty;

        /// <summary>
        /// Halcon模板句柄
        /// </summary>
        public HTuple hvModel;

        /// <summary>
        /// 模板图片
        /// </summary>
        public HObject hoImage;

        /// <summary>
        /// Halcon模板类型
        /// </summary>
        public ModelType Type = ModelType.ShapeModel;

        /// <summary>
        /// 加载模板(带.spm)
        /// </summary>
        /// <param name="fullPath">完整路径带.spm</param>
        /// <returns></returns>
        public bool Load(string fullPath)
        {
            try
            {
                if (string.IsNullOrEmpty(fullPath))
                    return false;

                string filePath = Path.GetFullPath(fullPath);
                ModelFullPath = fullPath;
                ModelName = Path.GetFileNameWithoutExtension(fullPath);
                // 使用 Path.GetExtension 提取扩展名
                string extension = Path.GetExtension(filePath);
                switch (extension)
                {
                    case ".spm":
                        if (File.Exists(ModelFullPath))
                            HOperatorSet.ReadShapeModel(ModelFullPath, out hvModel);
                        Type = ModelType.ShapeModel;
                        break;
                    case ".dfm":
                        if (File.Exists(ModelFullPath))
                            HOperatorSet.ReadDeformableModel(ModelFullPath, out hvModel);
                        Type = ModelType.LocalDeformableModel;
                        break;
                    default:
                        hvModel = new HTuple();
                        Type = ModelType.None;
                        return false;
                }

                string ImageFileName = Path.GetFileNameWithoutExtension(fullPath);
                string ImageFullPath = filePath + "\\" + ImageFileName + ".bmp";
                if (File.Exists(ImageFullPath))
                    HOperatorSet.ReadImage(out hoImage, ImageFullPath);
                return true;
            }
            catch { hvModel = new HTuple(); Type = ModelType.None; return false; }
        }

        /// <summary>
        /// 加载模板(带.json)
        /// </summary>
        /// <param name="fullPath">完整路径带.json</param>
        /// <returns></returns>
        public bool Load(string fullPath, string modelType)
        {
            try
            {
                if (string.IsNullOrEmpty(fullPath))
                    return false;

                string filePath = Path.GetDirectoryName(fullPath);
                ModelName = Path.GetFileNameWithoutExtension(fullPath);
                ModelFullPath = filePath + "\\" + ModelName;
                switch (modelType.ToString())
                {
                    case "形状":
                        ModelFullPath += ".spm";
                        if (File.Exists(ModelFullPath))
                            HOperatorSet.ReadShapeModel(ModelFullPath, out hvModel);
                        Type = ModelType.ShapeModel;
                        break;
                    case "可形变":
                        ModelFullPath += ".dfm";
                        if (File.Exists(ModelFullPath))
                            HOperatorSet.ReadDeformableModel(ModelFullPath, out hvModel);
                        Type = ModelType.LocalDeformableModel;
                        break;
                    default:
                        Type = ModelType.None;
                        return false;
                }

                string ImageFileName = Path.GetFileNameWithoutExtension(fullPath);
                string ImageFullPath = filePath + "\\" + ImageFileName + ".bmp";
                if (File.Exists(ImageFullPath))
                    HOperatorSet.ReadImage(out hoImage, ImageFullPath);
                return true;
            }
            catch { Type = ModelType.None; return false; }
        }

        /// <summary>
        /// 保存模板(路径带.spm)
        /// </summary>
        /// <param name="fullPath">带.spm</param>
        /// <returns></returns>
        public bool Save(string fullPath)
        {
            try
            {
                if (string.IsNullOrEmpty(fullPath))
                    return false;

                string filePath = Path.GetDirectoryName(fullPath);
                //判断文件夹是否存在
                if (!Directory.Exists(filePath))
                {
                    try
                    {
                        Directory.CreateDirectory(filePath);
                    }
                    catch (Exception)
                    { }
                }

                ModelName = Path.GetFileNameWithoutExtension(fullPath);
                // 使用 Path.GetExtension 提取扩展名
                string extension = Path.GetExtension(filePath);
                switch (extension)
                {
                    case ".spm":
                        HOperatorSet.WriteShapeModel(hvModel, fullPath);
                        Type = ModelType.ShapeModel;
                        break;
                    case ".dfm":
                        HOperatorSet.WriteDeformableModel(hvModel, fullPath);
                        Type = ModelType.LocalDeformableModel;
                        break;
                    default:
                        hvModel = new HTuple();
                        HOperatorSet.WriteDeformableModel(hvModel, fullPath);
                        Type = ModelType.None;
                        break;
                }

                string ImageFileName = Path.GetFileNameWithoutExtension(fullPath);
                string ImageFullPath = filePath + "\\" + ImageFileName + ".bmp";
                HOperatorSet.WriteImage(hoImage, "bmp", 0, ImageFullPath);
                return true;
            }
            catch { return false; }
        }

        /// <summary>
        /// 保存模板(路径带.json)
        /// </summary>
        /// <param name="fullPath">带.json</param>
        /// <returns></returns>
        public bool Save(string fullPath, ModelType modelType)
        {
            try
            {
                if (string.IsNullOrEmpty(fullPath))
                    return false;

                string filePath = Path.GetDirectoryName(fullPath);
                //判断文件夹是否存在
                if (!Directory.Exists(filePath))
                {
                    try
                    {
                        Directory.CreateDirectory(filePath);
                    }
                    catch (Exception)
                    { }
                }

                ModelName = Path.GetFileNameWithoutExtension(fullPath);
                ModelFullPath = filePath + "\\" + ModelName;
                switch (modelType.ToString())
                {
                    case "ShapeModel":
                        ModelFullPath += ".spm";
                        HOperatorSet.WriteShapeModel(hvModel, ModelFullPath);
                        Type = ModelType.ShapeModel;
                        break;
                    case "LocalDeformableModel":
                        ModelFullPath += ".spm";
                        HOperatorSet.WriteDeformableModel(hvModel, ModelFullPath);
                        Type = ModelType.LocalDeformableModel;
                        break;
                    default:
                        hvModel = new HTuple();
                        Type = ModelType.None;
                        break;
                }

                string ImageFileName = Path.GetFileNameWithoutExtension(fullPath);
                string ImageFullPath = filePath + "\\" + ImageFileName + ".bmp";
                HOperatorSet.WriteImage(hoImage, "bmp", 0, ImageFullPath);
                return true;
            }
            catch { return false; }
        }

    }
}

Step3 设计UI

UI设计读者可自行完成 这里展示的是用WinForm实现的

结果展示