using HalconDotNet;
using Newtonsoft.Json;
using OpenCvSharp;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Text;
using static LB_VisionProcesses.Alogrithms.OpenCvSharp.FindModelTool;
using Point = OpenCvSharp.Point;
using Size = OpenCvSharp.Size;

namespace LB_VisionProcesses.Alogrithms.OpenCvSharp
{
    [Process("OpenCvSharp_模板匹配工具", Category = "OpenCvSharp工具", Description = "创建OpenCvSharp_模板匹配工具")]
    public class FindModelTool : TAlgorithm
    {
        public enum ModelType { 灰度匹配 };

        public OModel ModelID = new OModel();

        public FindModelTool()
        {
            strProcessClass = "LB_VisionProcesses.Alogrithms.OpenCvSharp.FindModelTool";
            strProcessName = "OpenCvSharp_模板匹配工具";

            Params.Inputs.Add("ModelType", 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：贪婪度,搜索启发式,一般都设为2,越小速度越快,容易出现找不到的情况
            Params.Inputs.Add("Greediness", 2);
            Params.Inputs.Add("ResultType", "");

            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("Phi", new List<double>());
            Params.Outputs.Add("Score", new List<double>());
            Params.Outputs.Add("Count", 0);
        }

        private static readonly object lockObj = new object();
        /// <summary>
        /// 运行算子
        /// </summary>
        public override void TAlgorithmMain()
        {
            lock (lockObj)
            {
                try
                {
                    if (InputImage == null)
                    {
                        Msg = "输入图片为空";
                        Result = false;
                        return;
                    }
                    if (!(InputImage is Mat))
                    {
                        Msg = "输入图片格式不为Mat";
                        Result = false;
                        return;
                    }

                    #region 裁剪区域
                    object DomainImage = null;

                    if (!ReduceDomainImage(InputImage, ref DomainImage))
                    {
                        Msg = "裁剪区域失败";
                        Result = false;
                        return;
                    }

                    Mat hoDomainImage = DomainImage as Mat;
                    //判断是否为灰度图
                    try
                    {
                        if (hoDomainImage.Channels() != 1)
                            Cv2.CvtColor(hoDomainImage, hoDomainImage, ColorConversionCodes.RGB2GRAY);

                        //转换后再次检查是否为灰度图
                        if (hoDomainImage.Channels() != 1)
                        {
                            Msg = "输入图片不为灰度图";
                            Result = false;
                            return;
                        }
                    }
                    catch
                    {
                        Msg = "输入图片不为灰度图且转换失败";
                        Result = false;
                        return;
                    }
                    #endregion

                    //判断是否有模板
                    if (ModelID.hoImage == null || ModelID.hoImage.Empty())
                    {
                        Msg = "未创建模板";
                        Result = false;
                        return;
                    }

                    #region 算子逻辑
                    Record = new ObjectRecord();
                    ModelType type = ModelID.Type;
                    int ho_ModelWidth = ModelID.Width;
                    int ho_ModelHeight = ModelID.Height;

                    double AngleStart = Convert.ToDouble(Params.Inputs["AngleStart"]);
                    double AngleExtent = Convert.ToDouble(Params.Inputs["AngleExtent"]);
                    double MinScore = Convert.ToDouble(Params.Inputs["MinScore"]);
                    int NumMatches = ProcessParams.ConvertToInt32(Params.Inputs["NumMatches"]);
                    double MaxOverlap = Convert.ToDouble(Params.Inputs["MaxOverlap"]);
                    string SubPixel = ProcessParams.ConvertToString(Params.Inputs["SubPixel"]);
                    string NumLevels = ProcessParams.ConvertToString(Params.Inputs["NumLevels"]);
                    double Greediness = Convert.ToDouble(Params.Inputs["Greediness"]);

                    double ScaleRMin = Convert.ToDouble(Params.Inputs["ScaleRMin"]);
                    double ScaleRMax = Convert.ToDouble(Params.Inputs["ScaleRMax"]);
                    double ScaleCMin = Convert.ToDouble(Params.Inputs["ScaleCMin"]);
                    double ScaleCMax = Convert.ToDouble(Params.Inputs["ScaleCMax"]);

                    double ScaleMin = ScaleCMin > ScaleRMin ? ScaleRMin : ScaleCMin;
                    double ScaleMax = ScaleCMax > ScaleRMax ? ScaleRMax : ScaleCMax;
                    double ScaleStep = (ScaleMax - ScaleMin) / Greediness;

                    List<RotatedRect> results = new List<RotatedRect>();
                    switch (type)
                    {
                        case ModelType.灰度匹配:
                            // 执行灰度匹配
                            results = MultiAngleTemplateMatch(hoDomainImage, ModelID.hoImage, AngleStart, AngleStart + AngleExtent, AngleExtent / Greediness
                                , ScaleMin, ScaleMax, ScaleStep, MinScore, MaxOverlap);

                            break;
                        default:
                            Msg = "不支持的模板";
                            Result = false;
                            return;
                    }
                    #endregion

                    #region 结果处理
                    List<double> CenterX = new List<double>();
                    List<double> CenterY = new List<double>();
                    List<double> Phi = new List<double>();
                    List<double> Score = new List<double>();
                    for (int i = 0; i < results.Count; i++)
                    {
                        CenterX.Add(results[i].Center.X);
                        CenterY.Add(results[i].Center.Y);
                        Phi.Add(results[i].Angle / 180 * Math.PI);

                        HOperatorSet.GenRectangle2(out HObject hRectangle, CenterY[i], CenterX[i], Phi[i], ho_ModelWidth / 2, ho_ModelHeight / 2);
                        ((ObjectRecord)Record).AddRecord(hRectangle);
                    }

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

                    #region 生成OutputImage给后续处理
                    try
                    {
                        OutputImage = hoDomainImage;
                    }
                    catch (Exception ex)
                    {
                        Msg = "生成OutputImage失败,原因是:" + ex.ToString();
                        Result = false;
                        return;
                    }
                    #endregion

                    if (Msg == "运行超时")
                    {
                        Result = false;
                        Record.ChangeAll2False();
                        return;
                    }

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

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

                    Msg = "运行成功";
                    Result = true;
                    return;
                }
                catch (Exception ex)
                {
                    Msg = "运行失败,原因是:" + ex.ToString().TrimEnd();
                    OutputImage = null;
                    Result = false;
                    return;
                }
                finally
                {
                    if (!Result)
                    {
                        Params.Outputs["CenterX"] = 0;
                        Params.Outputs["CenterY"] = 0;
                        Params.Outputs["Phi"] = 0;
                        Params.Outputs["Score"] = 0;
                        Params.Outputs["Count"] = 0;
                    }
                    bCompleted = true;
                    #region 内存释放

                    #endregion
                }
            }
        }

        /// <summary>
        /// 带角度的灰度匹配
        /// </summary>
        /// <param name="source"></param>
        /// <param name="template"></param>
        /// <param name="startAngle"></param>
        /// <param name="endAngle"></param>
        /// <param name="angleStep"></param>
        /// <param name="scaleStart"></param>
        /// <param name="scaleEnd"></param>
        /// <param name="scaleStep"></param>
        /// <param name="threshold"></param>
        /// <param name="NMS"></param>
        /// <returns></returns>
        public static List<RotatedRect> MultiAngleTemplateMatch(
               Mat source,
               Mat template,
               double startAngle = 0,
               double endAngle = 360,
               double angleStep = 10,
               double scaleStart = 0.5,
               double scaleEnd = 2.0,
               double scaleStep = 0.1,
               double threshold = 0.8,
               double NMS = 0.3)
        {
            var allMatches = new List<MatchResult>();

            // 生成角度序列
            var angles = GenerateAngleSequence(startAngle, endAngle, angleStep);

            // 生成缩放序列
            var scales = GenerateScaleSequence(scaleStart, scaleEnd, scaleStep);

            // 多线程加速方法[存在匹配结果不一致的情况]
            //allMatches = MultiScaleAngleTemplateMatchFullParallel(source, template, scales, angles, threshold);

            foreach (double scale in scales)
            {
                // 缩放模板
                Mat scaledTemplate = new Mat();
                if (scale != 1.0)
                {
                    Cv2.Resize(template, scaledTemplate,
                        new Size(template.Width * scale, template.Height * scale));
                }
                else
                    scaledTemplate = template.Clone();

                if (scaledTemplate.Width > source.Width || scaledTemplate.Height > source.Height)
                    continue;

                foreach (double angle in angles)
                {
                    // 旋转模板
                    using (Mat rotatedTemplate = RotateImageForTemplateMatching(scaledTemplate, angle))
                    {
                        if (rotatedTemplate.Empty()) continue;

                        using (Mat resultMatrix = new Mat())
                        {
                            Cv2.MatchTemplate(source, rotatedTemplate, resultMatrix,
                                TemplateMatchModes.CCoeffNormed);

                            // 查找最佳匹配位置
                            double minVal, maxVal;
                            Point minLoc, maxLoc;
                            Cv2.MinMaxLoc(resultMatrix, out minVal, out maxVal, out minLoc, out maxLoc);

                            if (maxVal >= threshold)
                            {
                                var rotatedRect = new RotatedRect(
                                    new Point2f(maxLoc.X + rotatedTemplate.Width / 2.0f,
                                              maxLoc.Y + rotatedTemplate.Height / 2.0f),
                                    new Size2f(rotatedTemplate.Width, rotatedTemplate.Height),
                                    (float)angle);

                                allMatches.Add(new MatchResult
                                {
                                    RotatedRect = rotatedRect,
                                    Score = maxVal,
                                    Scale = scale
                                });
                            }
                        }
                    }
                }
            }

            // 应用旋转矩形的非极大值抑制
            return ApplyRotatedNMS(allMatches, NMS);
        }

        public static List<MatchResult> MultiScaleAngleTemplateMatchFullParallel(
            Mat source,
            Mat template,
            double[] scales,
            double[] angles,
            double threshold = 0.8)
        {
            var allMatches = new ConcurrentBag<MatchResult>();

            // 预处理源图像
            // 创建所有尺度-角度组合
            var combinations = from scale in scales
                               from angle in angles
                               select new { Scale = scale, Angle = angle };

            Parallel.ForEach(combinations, combination =>
            {
                try
                {
                    ProcessScaleAngleCombination(source, template,
                        combination.Scale, combination.Angle, threshold, allMatches);
                }
                catch (Exception ex)
                {
                    Debug.WriteLine($"处理尺度 {combination.Scale}, 角度 {combination.Angle} 时出错: {ex.Message}");
                }
            });

            return allMatches.ToList();
        }

        private static void ProcessScaleAngleCombination(Mat source, Mat template,
            double scale, double angle, double threshold, ConcurrentBag<MatchResult> allMatches)
        {
            Mat scaledTemplate = new Mat();
            // 缩放
            if (scale != 1.0)
            {
                Cv2.Resize(template, scaledTemplate,
                    new Size(template.Width * scale, template.Height * scale));
            }
            else
            {
                scaledTemplate = template.Clone();
            }

            if (scaledTemplate.Width > source.Width || scaledTemplate.Height > source.Height)
                return;

            // 旋转
            using (Mat rotatedTemplate = RotateImageForTemplateMatching(scaledTemplate, angle))
            {
                if (rotatedTemplate.Empty()) return;

                using (Mat resultMatrix = new Mat())
                {
                    Cv2.MatchTemplate(source, rotatedTemplate, resultMatrix,
                        TemplateMatchModes.CCoeffNormed);

                    double minVal, maxVal;
                    Point minLoc, maxLoc;
                    Cv2.MinMaxLoc(resultMatrix, out minVal, out maxVal, out minLoc, out maxLoc);

                    if (maxVal >= threshold)
                    {
                        var rotatedRect = new RotatedRect(
                            new Point2f(maxLoc.X + rotatedTemplate.Width / 2.0f,
                                      maxLoc.Y + rotatedTemplate.Height / 2.0f),
                            new Size2f(rotatedTemplate.Width, rotatedTemplate.Height),
                            (float)angle);

                        allMatches.Add(new MatchResult
                        {
                            RotatedRect = rotatedRect,
                            Score = maxVal,
                            Scale = scale
                        });
                    }
                }
            }
        }

        public static Mat RotateImageForTemplateMatching(Mat template, double angle, double scale = 1.0)
        {
            if (template.Empty())
                return new Mat();

            try
            {
                double radians = angle * Math.PI / 180.0;
                double sin = Math.Abs(Math.Sin(radians));
                double cos = Math.Abs(Math.Cos(radians));

                int newWidth = (int)Math.Ceiling((template.Width * cos + template.Height * sin) * scale);
                int newHeight = (int)Math.Ceiling((template.Width * sin + template.Height * cos) * scale);

                // 确保使用相同的类型创建画布
                Mat canvas = new Mat(newHeight, newWidth, template.Type(), Scalar.Black);

                int xOffset = (newWidth - template.Width) / 2;
                int yOffset = (newHeight - template.Height) / 2;

                Rect roi = new Rect(xOffset, yOffset, template.Width, template.Height);
                using (Mat canvasRoi = new Mat(canvas, roi))
                {
                    template.CopyTo(canvasRoi);
                }

                Point2f center = new Point2f(newWidth / 2.0f, newHeight / 2.0f);

                using (Mat rotationMatrix = Cv2.GetRotationMatrix2D(center, angle, scale))
                {
                    Mat rotated = new Mat();
                    Cv2.WarpAffine(canvas, rotated, rotationMatrix, new Size(newWidth, newHeight),
                                  InterpolationFlags.Linear, BorderTypes.Constant, Scalar.Black);

                    // 确保输出类型与输入一致
                    if (rotated.Type() != template.Type())
                    {
                        Mat converted = new Mat();
                        rotated.ConvertTo(converted, template.Type());
                        rotated.Dispose();
                        canvas.Dispose();
                        return converted;
                    }

                    canvas.Dispose();
                    return rotated;
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"旋转图像时出错: {ex.Message}");
                return new Mat();
            }
        }

        private static List<RotatedRect> ApplyRotatedNMS(List<MatchResult> matches, double overlapThreshold)
        {
            var results = new List<RotatedRect>();
            var remainingMatches = new List<MatchResult>(matches);

            while (remainingMatches.Count > 0)
            {
                // 取分数最高的匹配
                var bestMatch = remainingMatches[0];
                results.Add(bestMatch.RotatedRect);
                remainingMatches.RemoveAt(0);

                // 移除与最佳匹配重叠度高的其他匹配
                for (int i = remainingMatches.Count - 1; i >= 0; i--)
                {
                    double overlap = CalculateRotatedOverlap(bestMatch.RotatedRect,
                        remainingMatches[i].RotatedRect);

                    if (overlap > overlapThreshold)
                    {
                        remainingMatches.RemoveAt(i);
                    }
                }
            }

            return results;
        }

        public class MatchResult
        {
            public RotatedRect RotatedRect { get; set; }
            public double Score { get; set; }
            public double Scale { get; set; }
        }

        private static double CalculateRotatedOverlap(RotatedRect rect1, RotatedRect rect2)
        {
            // 计算两个旋转矩形的交并比
            Point2f[] vertices1 = rect1.Points();
            Point2f[] vertices2 = rect2.Points();

            // 使用轮廓面积计算重叠度
            using (Mat img1 = new Mat(1000, 1000, MatType.CV_8UC1, Scalar.Black))
            using (Mat img2 = new Mat(1000, 1000, MatType.CV_8UC1, Scalar.Black))
            {
                // 绘制第一个矩形
                Point[] points1 = vertices1.Select(p => new Point(p.X + 500, p.Y + 500)).ToArray();
                Cv2.FillConvexPoly(img1, points1, Scalar.White);

                // 绘制第二个矩形
                Point[] points2 = vertices2.Select(p => new Point(p.X + 500, p.Y + 500)).ToArray();
                Cv2.FillConvexPoly(img2, points2, Scalar.White);

                // 计算交集
                using (Mat intersection = new Mat())
                {
                    Cv2.BitwiseAnd(img1, img2, intersection);

                    double intersectionArea = Cv2.CountNonZero(intersection);
                    double unionArea = Cv2.CountNonZero(img1) + Cv2.CountNonZero(img2) - intersectionArea;

                    return intersectionArea / unionArea;
                }
            }
        }

        private static double[] GenerateAngleSequence(double start, double end, double step)
        {
            var angles = new List<double>();
            for (double angle = start; angle < end; angle += step)
            {
                angles.Add(angle);
            }
            return angles.ToArray();
        }

        private static double[] GenerateScaleSequence(double start, double end, double step)
        {
            var scales = new List<double>();
            for (double scale = start; scale <= end; scale += step)
            {
                scales.Add(scale);
            }
            return scales.ToArray();
        }

        public bool CreateModel(Mat Template, ModelType modelType = ModelType.灰度匹配, string NumLevels = "auto"
            , double AngleStart = -5, double AngleExtent = 10, string AngleStep = "auto"
            , double ScaleRMin = 0.9, double ScaleRMax = 1.1, string ScaleRStep = "auto"
            , double ScaleCMin = 1.1, double ScaleCMax = 0.9, string ScaleCStep = "auto"
            , string Optimization = "none", string Metric = "ignore_local_polarity"
            , string Contrast = "auto", int MinContrast = 10)
        {
            try
            {
                if (Template == null || Template.Empty())
                    Template = new Mat();

                #region 参数介绍
                //Template: : //reduce_domain后的模板图像
                //NumLevels ,//金字塔的层数，可设为“auto”或0—10的整数
                //AngleStart ,//模板旋转的起始角度
                //AngleExtent ,//模板旋转角度范围, >=0
                //AngleStep ,//旋转角度的步长， >=0 and <=pi/16
                //Optimization ,//设置模板优化和模板创建方法
                //Metric , //匹配方法设置
                //Contrast ,//设置对比度
                //MinContrast // 设置最小对比度
                #endregion
                switch (modelType)
                {
                    case ModelType.灰度匹配:
                        //HOperatorSet.CreateLocalDeformableModel(Template, NumLevels == "auto" ? NumLevels : Convert.ToInt16(NumLevels)
                        //    , AngleStart, AngleExtent, AngleStep == "auto" ? AngleStep : Convert.ToDouble(AngleStep)
                        //    , ScaleRMin, ScaleRMax, ScaleRStep == "auto" ? ScaleRStep : Convert.ToDouble(ScaleRStep)
                        //    , ScaleCMin, ScaleCMax, ScaleCStep == "auto" ? ScaleCStep : Convert.ToDouble(ScaleCStep)
                        //    , Optimization, Metric
                        //    , Contrast, MinContrast
                        //    , new HTuple(), new HTuple()
                        //    , out ModelID.hvModel);
                        ModelID.hoImage = Template.Clone();
                        ModelID.Type = ModelType.灰度匹配;
                        return true;
                    default:
                        //HOperatorSet.CreateAnisoShapeModel(Template, NumLevels == "auto" ? NumLevels : Convert.ToInt16(NumLevels)
                        //    , AngleStart, AngleExtent, AngleStep == "auto" ? AngleStep : Convert.ToDouble(AngleStep)
                        //    , ScaleRMin, ScaleRMax, ScaleRStep == "auto" ? ScaleRStep : Convert.ToDouble(ScaleRStep)
                        //    , ScaleCMin, ScaleCMax, ScaleCStep == "auto" ? ScaleCStep : Convert.ToDouble(ScaleCStep)
                        //    , Optimization, Metric
                        //    , Contrast, MinContrast, out ModelID.hvModel);
                        ModelID.hoImage = Template.Clone();
                        ModelID.Type = ModelType.灰度匹配;
                        return true;
                }
            }
            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"))
                {
                    Debug.WriteLine("文件路径不完整");
                    return false;
                }

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

                // 获取不带文件名的目录路径
                string directoryPath = Path.GetDirectoryName(fullPath);
                strProcessName = Path.GetFileNameWithoutExtension(fullPath);
                // 修正真实路径,模板匹配工具其路径为一个文件夹,而不是一个文件
                fullPath = directoryPath + "\\" + strProcessName + "\\" + strProcessName + ".json";

                if (!File.Exists(fullPath))
                {
                    Debug.WriteLine("文件不存在创建空文件");
                    ModelID = new OModel(fullPath, ModelType.灰度匹配, strProcessName);
                    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<ProcessParams>(strJson);
                if (Params == null)
                    return false;

                // 反序列化后修复数据
                Params.FixDeserializedData();
                strProcessName = Path.GetFileNameWithoutExtension(fullPath);

                if (!Enum.TryParse(Params.Inputs["ModelType"].ToString(), out ModelType modelType))
                    return false;

                if (!ModelID.Load(fullPath, modelType))
                    return false;

                return true;
            }
            catch { return false; }
        }

        /// <summary>
        /// 保存算法
        /// </summary>
        /// <param name="filePath">不带.json</param>
        /// <returns></returns>
        public override bool Save(string filePath)
        {
            try
            {
                // 修正真实路径,模板匹配工具其路径为一个文件夹,而不是一个文件
                filePath += ("\\" + strProcessName);
                Params.Inputs.Add("ModelType", ModelID.Type.ToString());
                if (!base.Save(filePath)
                    || !ModelID.Save(filePath + "\\" + strProcessName + ".json", ModelID.Type))
                    return false;

                return true;
            }
            catch { return false; }
        }
    }

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

        public OModel(string modelFullPath, ModelType modelType, string modelName)
        {
            ModelFullPath = modelFullPath;
            ModelName = modelName;
            Type = modelType;
            switch (modelType)
            {
                case ModelType.灰度匹配:
                    Load(ModelFullPath, modelType);
                    break;
                default:
                    Load(ModelFullPath, modelType);
                    break;
            }
        }

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

        /// <summary>
        /// 模板名称
        /// </summary>
        public string ModelName
        {
            get { return Path.GetFileNameWithoutExtension(ModelFullPath); }
            set
            {
                // 获取文件的扩展名（包括点）
                string fileExtension = Path.GetExtension(ModelFullPath);

                // 获取文件所在的文件夹路径
                string directoryPath = Path.GetDirectoryName(ModelFullPath);

                ModelFullPath = directoryPath + "\\" + value + fileExtension;
            }
        }

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

        public int Width
        {
            get
            {
                if (hoImage == null || hoImage.Empty())
                    return 0;
                return hoImage.Width;
            }
        }

        public int Height
        {
            get
            {
                if (hoImage == null || hoImage.Empty())
                    return 0;
                return hoImage.Height;
            }
        }

        /// <summary>
        /// 模板类型
        /// </summary>
        public ModelType Type = ModelType.灰度匹配;

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

                string filePath = Path.GetDirectoryName(fullPath);
                ModelName = Path.GetFileNameWithoutExtension(fullPath);
                ModelFullPath = filePath + "\\" + ModelName;
                ModelFullPath += ".model";
                Type = modelType;
                //switch (modelType)
                //{
                //    case ModelType.局部变形模板:
                //        ModelFullPath += ".dfm";
                //        if (File.Exists(ModelFullPath))
                //            HOperatorSet.ReadDeformableModel(ModelFullPath, out hvModel);
                //        break;
                //    case ModelType.各向异形模板:
                //    default:
                //        if (File.Exists(ModelFullPath))
                //            HOperatorSet.ReadShapeModel(ModelFullPath, out hvModel);
                //        break;
                //}

                string ImageFileName = Path.GetFileNameWithoutExtension(fullPath);
                string ImageFullPath = filePath + "\\" + ImageFileName + ".bmp";
                if (File.Exists(ImageFullPath))
                    hoImage = Cv2.ImRead(ImageFullPath);

                if (hoImage == null || hoImage.Empty())
                    return false;

                if (hoImage.Channels() != 1)
                    Cv2.CvtColor(hoImage, hoImage, ColorConversionCodes.RGB2GRAY);

                return true;
            }
            catch { Type = ModelType.灰度匹配; return false; }
        }

        /// <summary>
        /// 保存模板(路径带.model)
        /// </summary>
        /// <param name="fullPath">带.model</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 提取扩展名
                //switch (Type)
                //{
                //    case ModelType.局部变形模板:
                //        HOperatorSet.WriteDeformableModel(hvModel, fullPath);
                //        break;
                //    case ModelType.各向异形模板:
                //    default:
                //        HOperatorSet.WriteShapeModel(hvModel, fullPath);
                //        break;
                //}

                string ImageFileName = Path.GetFileNameWithoutExtension(fullPath);
                string ImageFullPath = filePath + "\\" + ImageFileName + ".bmp";
                Cv2.ImWrite(ImageFullPath, hoImage);
                //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 + ".model";
                Type = modelType;
                //switch (modelType)
                //{
                //    case ModelType.各向异形模板:
                //        HOperatorSet.WriteDeformableModel(hvModel, ModelFullPath);
                //        break;
                //    default:
                //        HOperatorSet.WriteShapeModel(hvModel, ModelFullPath);
                //        break;
                //}

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