using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using HalconDotNet;

namespace HalconTools
{
    public class HalconTool
    {
        #region 各种单方法以及定义

        #region 定义
        public HWndCtrl viewController;

        public ListenEventCreater resultCreater = new ListenEventCreater();

        public struct FindLineResult
        {
            public string SerialNumer;
            public FitLineResult fitLineResult;
        }

        public struct FindCircleResult
        {
            public string SerialNumber;
            public FitCircleResult fitCircleResult;
        }

        public struct PatternMatchResult
        {
            public string SerialNumber;
            public MatchingResult matchingResult;
        }

        public struct FindContourResult
        {
            public string SerialNumber;
            public ContourResult contourResult;
        }

        public List<FindLineResult> findLineResults = new List<FindLineResult>();
        public List<FindCircleResult> findCircleResults = new List<FindCircleResult>();
        public List<PatternMatchResult> patternMatchResults = new List<PatternMatchResult>();

        public FindLineResult findLineResult = new FindLineResult();
        public FindCircleResult findCircleResult = new FindCircleResult();
        public PatternMatchResult patternMatchResult = new PatternMatchResult();
        public FindContourResult contourResult = new FindContourResult();

        public FitAssistant mFitAssistant = new FitAssistant();
        public HImage image;
        public FitLineResult result;
        public MatchingAssistant mMatchingAssistant = new MatchingAssistant();
        public ContourAssistant mContourAssistant = new ContourAssistant();


        public FitLineParam fitLinePara = new FitLineParam();
        public FitCircleParam fitCirclePara = new FitCircleParam();
        public MatchingParam matchingPara = new MatchingParam();
        public ContourParam contourPara = new ContourParam();
        public HImage hImage;

        public List<FitLineParam> fitLineParas = new List<FitLineParam>();
        public List<FitCircleParam> fitCircleParas = new List<FitCircleParam>();
        SerializeFileTool<List<FitLineParam>> sft1 = new SerializeFileTool<List<FitLineParam>>();
        SerializeFileTool<List<FitCircleParam>> sft2 = new SerializeFileTool<List<FitCircleParam>>();
        #endregion

        #region 初始化
        public void initHalconTool()
        {
            mFitAssistant.FitLineDone += new FitLineDelegate(mFitAssistant_FitLineDone);
            mFitAssistant.FitCircleDone += new FitCircleDelegate(mFitAssistant_FitCircleDone);
            mFitAssistant.NotifyIconObserverMessage += new FitMessageDelegate(mFitAssistant_NotifyIconObserverMessage);
            mMatchingAssistant.FindShapeModelDone += new FindShapeModelDelegate(mMatchingAssistant_FindShapeModelDone);
            mContourAssistant.ContourDone += new ContourDelegate(mContourAssistant_ContourDone);
            //mMatchingAssistant .NotifyIconObserver+=  

            string FolderPath = Application.StartupPath + "\\FitConfig";
            string FilePath;

            FilePath = FolderPath + "\\fitLineConfig.xml";
            fitLineParas = sft1.GetConfig(FilePath);

            FilePath = FolderPath + "\\fitCircleConfig.xml";
            fitCircleParas = sft2.GetConfig(FilePath);
        }



        public HalconTool()
        {
            JobImage = new HImage();
            mFitAssistant = new FitAssistant();
            mMatchingAssistant = new MatchingAssistant();
            initHalconTool();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="viewPort">fit算法的窗口</param>
        /// <param name="ModuleNum">匹配的模板数量</param>
        public HalconTool(HWindowControl viewPort, int ModuleNum)
        {
            mFitAssistant = new FitAssistant(viewPort);
            mMatchingAssistant = new MatchingAssistant(ModuleNum);
            initHalconTool();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="viewPort">fit算法的窗口</param>
        public HalconTool(HWindowControl viewPort)
        {
            mFitAssistant = new FitAssistant(viewPort);
            initHalconTool();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ModuleNum">匹配的模板数量</param>
        public HalconTool(int ModuleNum)
        {
            mMatchingAssistant = new MatchingAssistant(ModuleNum);
            initHalconTool();
        }
        #endregion

        #region 消息处理部分
        void mFitAssistant_FitCircleDone(object sender, HImage image, FitCircleResult result)
        {
            if (findCircleResults == null) findCircleResults = new List<FindCircleResult>();
            findCircleResult.fitCircleResult = result;

            findCircleResults.Add(findCircleResult);

            //反馈消息
            resultCreater.ChangeValue(new EventData("FindCircleDone"));
        }

        void mFitAssistant_FitLineDone(object sender, HImage image, FitLineResult result)
        {
            ////画上找到的结果
            //mFitAssistant.FitLineGraphics(mFitAssistant.viewController, image, result);

            //结果处理
            if (findLineResults == null) findLineResults = new List<FindLineResult>();
            findLineResult.fitLineResult = result;

            findLineResults.Add(findLineResult);

            //反馈消息
            resultCreater.ChangeValue(new EventData("FindLineDone"));
        }


        void mMatchingAssistant_FindShapeModelDone(object sender, HImage image, MatchingResult result)
        {
            if (patternMatchResults == null) patternMatchResults = new List<PatternMatchResult>();
            patternMatchResult.matchingResult = result;

            patternMatchResults.Add(patternMatchResult);

            resultCreater.ChangeValue(new EventData("MatchDone"));
        }

        void mFitAssistant_NotifyIconObserverMessage(int value)
        {
            //反馈没有找到的消息
            resultCreater.ChangeValue(new EventData("CanNotFind"));
        }

        void mContourAssistant_ContourDone(object sender, HImage image, ContourResult result)
        {
            contourResult.contourResult = result;
            resultCreater.ChangeValue(new EventData("ContourDone"));
        }
        #endregion

        #region 找线找圆部分
        /// <summary>
        /// 找直线
        /// </summary>
        /// <param name="sn">序列号</param>
        /// <param name="image">Halcon图像</param>
        /// <param name="para">找直线参数</param>
        public void FindLine(string sn, HImage image, FitLineParam para)
        {
            findLineResult.SerialNumer = sn;
            mFitAssistant.mImage = image;
            mFitAssistant.FitLine(para);
        }

        /// <summary>
        /// 找圆
        /// </summary>
        /// <param name="sn">序列号</param>
        /// <param name="image">Halcon图像</param>
        /// <param name="para">找圆参数</param>
        public void FindCircle(string sn, HImage image, FitCircleParam para)
        {
            findCircleResult.SerialNumber = sn;
            mFitAssistant.mImage = image;
            mFitAssistant.FitCircle(para);
        }

        /// <summary>
        /// 通过全局变量参数找直线
        /// </summary>
        private void ThFindLine()
        {
            mFitAssistant.mImage = hImage;
            mFitAssistant.FitLine(fitLinePara);
        }

        /// <summary>
        /// 通过全局变量参数找圆
        /// </summary>
        private void ThFindCircle()
        {
            mFitAssistant.mImage = hImage;
            mFitAssistant.FitCircle(fitCirclePara);
        }

        /// <summary>
        /// 用进程找直线
        /// </summary>
        /// <param name="sn"></param>
        /// <param name="image"></param>
        /// <param name="para"></param>
        public void ThreadFindLine(string sn, HImage image, FitLineParam para)
        {
            hImage = image;
            fitLinePara = para;

            Thread findLineThread = new Thread(ThFindLine);
            findLineThread.Start();
        }

        /// <summary>
        /// 用进程找圆
        /// </summary>
        /// <param name="sn"></param>
        /// <param name="image"></param>
        /// <param name="para"></param>
        public void ThreadFindCircle(string sn, HImage image, FitCircleParam para)
        {
            hImage = image;
            fitCirclePara = para;

            Thread findCircleThread = new Thread(ThFindCircle);
            findCircleThread.Start();
        }
        #endregion

        #region 匹配部分
        /// <summary>
        /// 创建模板（获取模板ID）
        /// </summary>
        /// <param name="sn">序列号</param>
        /// <param name="image">图像</param>
        /// <param name="para">参数</param>
        public void CreateModule(string sn, HImage image, MatchingParam para)
        {
            patternMatchResult.SerialNumber = sn;
            mMatchingAssistant.mImage = image;
            mMatchingAssistant.parameterSet = para;

            mMatchingAssistant.createShapeModel();
        }

        /// <summary>
        /// 匹配模板（已得到模板ID）
        /// </summary>
        /// <param name="sn">序列号</param>
        /// <param name="image">图像</param>
        /// <param name="para">参数</param>
        public void FindModule(string sn, HImage image, MatchingParam para)
        {
            patternMatchResult.SerialNumber = sn;
            mMatchingAssistant.mImage = image;
            mMatchingAssistant.parameterSet = para;

            mMatchingAssistant.detectShapeModel();
        }

        /// <summary>
        /// 根据模板的地址匹配
        /// </summary>
        /// <param name="sn">序列号</param>
        /// <param name="image">图像</param>
        /// <param name="para">参数</param>
        /// <param name="modulePath">模板文件地址</param>
        public void PatterMatchWithModule(string sn, HImage image, MatchingParam para, string modulePath)
        {
            patternMatchResult.SerialNumber = sn;
            mMatchingAssistant.tImage = image;
            mMatchingAssistant.parameterSet = para;

            
            mMatchingAssistant.loadShapeModel(modulePath);
            mMatchingAssistant.detectShapeModel();
        }
        #endregion

        #region 找轮廓部分
        public void FindContour(string sn, HImage image, ContourParam para)
        {
            contourResult.SerialNumber = sn;
            mContourAssistant.mImage = image;
            mContourAssistant.mContourPara = para;
            mContourAssistant.Run();
        }
        #endregion

        #region 加载参数
        /// <summary>
        /// 加载匹配参数
        /// </summary>
        /// <param name="ParaPath"></param>
        public void LoadMatchingParameter(string ParaPath)
        {
            mMatchingAssistant.LoadPara(ParaPath);
            matchingPara = mMatchingAssistant.parameterSet;
        }

        /// <summary>
        /// 加载找直线的参数
        /// </summary>
        /// <param name="ParaPath">参数文件地址</param>
        public void LoadFitLineParameter(string ParaPath)
        {
            MeasureParamSave paramSave = new HalconTools.MeasureParamSave();
            paramSave = paramSave.Load(ParaPath);
            
            fitLinePara.hv_measure_Length1 = paramSave.hv_measure_Length1;
            fitLinePara.hv_measure_Length2 = paramSave.hv_measure_Length2;
            fitLinePara.hv_measure_sigma = paramSave.hv_measure_sigma;
            fitLinePara.hv_measure_position = paramSave.hv_measure_position;
            fitLinePara.hv_measure_transition = paramSave.hv_measure_transition;
            fitLinePara.hv_measure_number = paramSave.hv_measure_number;
            fitLinePara.hv_measure_threshold = paramSave.hv_measure_threshold;
            fitLinePara.hv_measure_interpolation = paramSave.hv_measure_interpolation;
        }

        /// <summary>
        /// 加载找圆参数
        /// </summary>
        /// <param name="ParaPath">参数文件地址</param>
        public void LoadFitCircleParameter(string ParaPath)
        {
            MeasureParamSave paramSave = new HalconTools.MeasureParamSave();
            paramSave = paramSave.Load(ParaPath);

            fitCirclePara.hv_measure_Length1 = paramSave.hv_measure_Length1;
            fitCirclePara.hv_measure_Length2 = paramSave.hv_measure_Length2;
            fitCirclePara.hv_measure_sigma = paramSave.hv_measure_sigma;
            fitCirclePara.hv_measure_position = paramSave.hv_measure_position;
            fitCirclePara.hv_measure_transition = paramSave.hv_measure_transition;
            fitCirclePara.hv_measure_number = paramSave.hv_measure_number;
            fitCirclePara.hv_measure_threshold = paramSave.hv_measure_threshold;
            fitCirclePara.hv_measure_interpolation = paramSave.hv_measure_interpolation;
        }

        /// <summary>
        /// 加载轮廓参数
        /// </summary>
        /// <param name="ParaPath">参数文件地址</param>
        public void LoadContourParameter(string ParaPath)
        {
            SerializeFileTool<ContourParam> sft = new SerializeFileTool<ContourParam>();
            contourPara = sft.GetConfig(ParaPath);
        }
        #endregion
        #endregion

        #region Job

        #region 定义

        public SerializeFileTool<List<Job>> sftJobs = new SerializeFileTool<List<Job>>();
        public List<Job> Jobs = new List<Job>();
        public List<JobResults> JobResults = new List<JobResults>();
        private JobResults tmpJobResults = new JobResults();
        private JobResult tmpJobResult = new JobResult();
        private FitLineResult tmpFitLineResult = new FitLineResult();
        public HImage JobImage;
        private JobAssistance mJobAssistance = new JobAssistance();

        #endregion

        public void LoadJobs()
        {
            string path = System.Windows.Forms.Application.StartupPath + "\\JobConfige\\JobConfige.xml";
            Jobs = sftJobs.GetConfig(path);
        }

        public void LoadJobs(string path)
        {
            Jobs = sftJobs.GetConfig(path);
        }

        /// <summary>
        /// 单个job运行方法（需程序员自己编写参数传递）
        /// </summary>
        /// <param name="index">序号</param>
        public void Run(int index)
        {
            if (JobImage == null) return;

            tmpJobResults = new JobResults();
            tmpJobResults.results = new List<JobResult>();
            tmpJobResults.name = Jobs[index].name;

            switch (index)
            {
                case 0:

                    for (int j = 0; j < 2; j++)
                    {
                        tmpJobResult = new JobResult();
                        tmpJobResult = mJobAssistance.ToolRun(JobImage, Jobs[index].tools[j]);
                        tmpJobResults.results.Add(tmpJobResult);
                    }
                    JobResults.Add(tmpJobResults);

                    break;

                case 1:
                case 2:
                case 3:
                case 4:

                    for (int j = 0; j < 4; j++)
                    {
                        tmpJobResult = new JobResult();
                        tmpJobResult = mJobAssistance.ToolRun(JobImage, Jobs[index].tools[j]);
                        tmpJobResults.results.Add(tmpJobResult);
                    }
                    JobResults.Add(tmpJobResults);

                    break;

                default:
                    break;
            }

            resultCreater.ChangeValue(new EventData(Jobs[index].name + "_Done"));
        }

        /// <summary>
        /// 单个job运行方法（需程序员自己编写参数传递）
        /// </summary>
        /// <param name="JobName">Job名称</param>
        public void Run(string JobName)
        {
            if (JobImage == null) return;

            tmpJobResults = new JobResults();
            tmpJobResults.results = new List<JobResult>();

            for (int i = 0; i < Jobs.Count; i++)
            {
                if (Jobs[i].name.Equals(JobName))
                {
                    tmpJobResults.name = Jobs[i].name;

                    switch (JobName)
                    {
                        case "JobLLMF":

                            for (int j = 0; j < 1; j++)
                            {
                                tmpJobResult = new JobResult();
                                tmpJobResult = mJobAssistance.ToolRun(JobImage, Jobs[i].tools[j]);

                                if (tmpJobResult.fitLineResult == null)
                                {
                                    resultCreater.ChangeValue(new EventData(JobName + "_Undone"));
                                    return;
                                }

                                tmpJobResults.results.Add(tmpJobResult);
                            }
                            JobResults.Add(tmpJobResults);

                            break;
                        default:
                            break;
                    }

                    break;
                }
            }

            resultCreater.ChangeValue(new EventData(JobName + "_Done"));
            JobImage.Dispose();
        }

        /// <summary>
        /// 清空结果
        /// </summary>
        public void Clear_JobResults()
        {
            JobResults.Clear();
        }

        #endregion

        #region 计算方法
        /// <summary>
        /// 计算2直线距离
        /// </summary>
        /// <param name="l1">直线1</param>
        /// <param name="l2">直线2</param>
        /// <returns>距离</returns>
        public double DistanceLine2Line(FitLineResult l1, FitLineResult l2)
        {
            HTuple tmp = new HTuple();

            HOperatorSet.DistancePl((l1.mRowStart + l1.mRowEnd) / 2, (l1.mColumnStart + l1.mColumnEnd) / 2,
                l2.mRowStart, l2.mColumnStart, l2.mRowEnd, l2.mColumnEnd, out tmp);

            return tmp.D;
        }

        /// <summary>
        /// 计算2直线交点
        /// </summary>
        /// <param name="l1">直线1</param>
        /// <param name="l2">直线2</param>
        /// <param name="x">交点x</param>
        /// <param name="y">交点y</param>
        public void IntersectionLine2Line(FitLineResult l1, FitLineResult l2, out double x, out double y)
        {
            HTuple row, col, isP;

            HOperatorSet.IntersectionLl(l1.mRowStart, l1.mColumnStart, l1.mRowEnd, l1.mColumnEnd,
                l2.mRowStart, l2.mColumnStart, l2.mRowEnd, l2.mColumnEnd,
                out row, out col, out isP);

            x = col.D;
            y = row.D;
        }

        /// <summary>
        /// 计算2直线交点
        /// </summary>
        /// <param name="Line1StartX"></param>
        /// <param name="Line1StartY"></param>
        /// <param name="Line1EndX"></param>
        /// <param name="Line1EndY"></param>
        /// <param name="Line2StartX"></param>
        /// <param name="Line2StartY"></param>
        /// <param name="Line2EndX"></param>
        /// <param name="Line2EndY"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public void IntersectionLine2Line(double Line1StartX, double Line1StartY, double Line1EndX, double Line1EndY,
            double Line2StartX, double Line2StartY, double Line2EndX, double Line2EndY, out double x, out double y)
        {
            HTuple row, col, isP;

            HOperatorSet.IntersectionLl((HTuple)Line1StartY, (HTuple)Line1StartX, (HTuple)Line1EndY, (HTuple)Line1EndX,
                (HTuple)Line2StartY, (HTuple)Line2StartX, (HTuple)Line2EndY, (HTuple)Line2EndX,
                out row, out col, out isP);

            x = col.D;
            y = row.D;
        }
        /// <summary>
        /// 计算直线与水平坐标的角度
        /// </summary>
        /// <param name="l1">直线1</param>
        /// <returns>角度</returns>
        public double AngleLine2HorizontialAxis(FitLineResult l1)
        {
            HTuple tmp;

            HOperatorSet.AngleLx(l1.mRowStart, l1.mColumnStart, l1.mRowEnd, l1.mColumnEnd, out tmp);

            return tmp.D / Math.PI * 180;
        }

        /// <summary>
        /// 计算点到点距离
        /// </summary>
        /// <param name="x1"></param>
        /// <param name="y1"></param>
        /// <param name="x2"></param>
        /// <param name="y2"></param>
        /// <returns></returns>
        public double DistanceP2P(double x1, double y1, double x2, double y2)
        {
            HTuple dis;
            HOperatorSet.DistancePp((HTuple)y1, (HTuple)x1, (HTuple)y2, (HTuple)x2, out dis);

            return dis.D;
        }

        /// <summary>
        /// 计算2直线的角度
        /// </summary>
        /// <param name="r1"></param>
        /// <param name="r2"></param>
        /// <returns></returns>
        public double AngleLine2Line(FitLineResult r1, FitLineResult r2)
        {
            HTuple angle;
            HOperatorSet.AngleLl(r1.mRowStart, r1.mColumnStart, r1.mRowEnd, r1.mColumnEnd,
                r2.mRowStart, r2.mColumnStart, r2.mRowEnd, r2.mColumnEnd, out angle);

            return angle.D / Math.PI * 180;
        }

        #endregion
    }
}