OTS/OTSIncAReportApp/1-UI/Control_Graph/OTSIncAReportGraphFuncation/OTSImageDisHelp.cs

using OpenCvSharp;
using OTSCLRINTERFACE;
using OTSCommon.Model;
using OTSIncAReportApp.DataOperation.DataAccess;
using OTSIncAReportApp.SysMgrTools;
using OTSIncAReportGraph.Class;
using OTSIncAReportGraph.Controls;
using OTSModelSharp.DTLBase;
using OTSModelSharp.ServiceInterface;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;

using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using Point = System.Drawing.Point;

namespace OTSIncAReportGraph.OTSIncAReportGraphFuncation
{
  public  class OTSImageDisHelp
    {
        #region 枚举定义
        /// <summary>
        /// 样品台X轴方向
        /// </summary>
        enum OTS_X_AXIS_DIRECTION
        {
            LEFT_TOWARD = 0,
            RIGHT_TOWARD = 1
        }

        /// <summary>
        /// 样品台Y轴方向
        /// </summary>
        enum OTS_Y_AXIS_DIRECTION
        {
            UP_TOWARD = 0,
            DOWN_TOWARD = 1
        }
        #endregion

        #region 定义变量

        private ResultFile resultFile = null;

        public ParticleSegmentation m_ParticleSegmentation;

        //记录field列表的原值
        public List<DisplayField> m_original_list_dfield = null;
        //记录原值,颗粒和线段
        public List<BaseObject> m_original_list_baseobject = null;


        NLog.Logger log;
        //field的数量
        public int m_field_count = 0;

        //particle的数量
        public int m_particle_count = 0;

        //加载使用的时间
        public string m_time_str = "";

        //加载使用时间计算时间段2
        public string m_time_str2 = "";

    

        //电镜设置对象
        public  ServiceInterface.HardwareController m_cfun = null;

        //是否已经连接到了电镜
        public bool m_SEMConnectionState = false;

        //连接到电镜的ID号
        public int m_SEM_ID = 0;

 
        #endregion

        #region 构造函数
     
        public OTSImageDisHelp( ResultFile result)
        {
            m_original_list_dfield = new List<DisplayField>();

            m_original_list_baseobject = new List<BaseObject>();
            resultFile = result;
            m_cfun = ServiceInterface.HardwareController.GetSemController();
            log = NLog.LogManager.GetCurrentClassLogger();
        }



        #endregion

        #region 封装自定义方法
        public Point GetOTSCoordLeftBottomPoint(List<Point> allFldPos)
        {
            //the ots coordinate system is always positive on the right and up direction.So the leftbottom point would be the smallest point.
            //找出最小的x,y用来做偏移运算
            int i_offset_x = 1000000000;
            int i_offset_y = 1000000000;

            //先取出最小的x,y
            for (int i = 0; i < allFldPos.Count; i++)
            {
                if (i_offset_x > allFldPos[i].X)
                {
                    i_offset_x = allFldPos[i].X;
                }
                if (i_offset_y > allFldPos[i].Y)
                {
                    i_offset_y = allFldPos[i].Y;
                }
            }
            return new Point(i_offset_x, i_offset_y);
        }
     
            public Point ConvertOTSCoordinateToScreenCoord(Point otsleftBottomPoint,double pixelSize, Point currenFldPos,RectangleF wholeImageRec,RectangleF singleImgRec)//
        {
           
               var OTSPoint=new Point(currenFldPos.X - otsleftBottomPoint.X, currenFldPos.Y - otsleftBottomPoint.Y);
            double screenHeight = wholeImageRec.Height + (0 - (int)(Convert.ToDouble(OTSPoint.Y) / pixelSize));//because the screen coordinate is downward rightward positive,so we need to translate the Y coordinate of the OTS system which is upward rightward positive.
            screenHeight = screenHeight - singleImgRec.Height;
            var screenPoint = new Point((int)(Convert.ToDouble(OTSPoint.X)/pixelSize), (int)screenHeight);

            return screenPoint;
        }

        public Rectangle ConvertAndGetMaxRect(List<Point> inPoints, int in_width, int in_height)
        {
            //首先要能确定下来，单个物理坐标的宽和高--------------------------------
            int i_wl_width = 0;
            int i_wl_height = 0;

            RectangleF ls_r = GetPhysicalFieldWidthAndHeight(inPoints,in_width,in_height);
            i_wl_width = (int)ls_r.Width;
            i_wl_height = (int)ls_r.Height;
            //-----------------------------------------------------------------------------

            int point_x_min = 10000000;
            int point_x_max = -10000000;
            int point_y_min = 10000000;
            int point_y_max = -10000000;

            for (int i = 0; i < inPoints.Count(); i++)
            {
                Point ls_point = inPoints[i];
                //取出正数最大x
                if (ls_point.X > point_x_max)
                    point_x_max = ls_point.X;
                if (ls_point.Y > point_y_max)
                    point_y_max = ls_point.Y;
                if (ls_point.X < point_x_min)
                    point_x_min = ls_point.X;
                if (ls_point.Y < point_y_min)
                    point_y_min = ls_point.Y;
            }

            //然后分别用最大值+abs(最小值),就是x,和y轴的总长值
            point_x_max = point_x_max - point_x_min;
            point_y_max = point_y_max - point_y_min;

            //该算法有个问题，就是不能直观的得到整个范围的大小，要除以倍数再补1能补充缺少的一个field视域**********
            point_x_max = ((point_x_max / i_wl_width) + 1) * i_wl_width;
            point_y_max = ((point_y_max / i_wl_height) + 1) * i_wl_height;

            //将物理宽高，变换成分辨率宽高
            if (i_wl_width != 0) point_x_max = (point_x_max / i_wl_width) * in_width; else point_x_max = 0;
            if (i_wl_height != 0) point_y_max = (point_y_max / i_wl_height) * in_height; else point_y_max = 0;

            Rectangle ret_rectangle = new Rectangle(0, 0, 0, 0);
            //判断一下防止出错，只有在有数据的情况下，进行赋值才行
            if (inPoints.Count > 0)
            {
                ret_rectangle = new Rectangle(0, 0, point_x_max, point_y_max);
            }

            //这样返回是物理坐标的总大小，应该返回像素坐标大小才对
            return ret_rectangle;
        }
        /// <summary>
        /// 计算单个field的物理大小 传入field的list,还有测量结果管理类对象，在无法计算出单field的物理大小的情况下，到这里取再计算得出
        /// </summary>
        /// <returns></returns>
        public RectangleF GetPhysicalFieldWidthAndHeight(List<Point> points,int imageWidth,int imageHeight)
        {
            int width_max = -10000000;
            int height_max = -10000000;

            int width_max2 = -10000000;
            int height_max2 = -10000000;

            //先找出最大的值，
            for (int i = 0; i < points.Count(); i++)
            {
                if (width_max < points[i].X)
                    width_max = points[i].X;
                if (height_max < points[i].Y)
                    height_max = points[i].Y;
            }

            //再找出第二大的值
            for (int i = 0; i < points.Count(); i++)
            {
                if (width_max2 < points[i].X && width_max != points[i].X)
                    width_max2 = points[i].X;
                if (height_max2 < points[i].Y && height_max != points[i].Y)
                    height_max2 = points[i].Y;
            }

            //需要针对第二大的值，获取时进行判断，感觉这里应该如果并未找到第二大的值的情况下，赋于0值，便于以后进行计算
            if (width_max2 == -10000000)
                width_max2 = width_max;
            if (height_max2 == -10000000)
                height_max2 = height_max;

            RectangleF ret_rect = new RectangleF(0, 0, width_max - width_max2, height_max - height_max2);

            //如果最后计算出的宽高有0则重新到测量数据中获取---------------------------------------
            if (ret_rect.Width == 0 || ret_rect.Height == 0)
            {

                //到参数中去取单个宽
                double d_scanFieldSize_width = Convert.ToDouble(((Dictionary<string, object>)resultFile.ResultInfo["SEMStageData"])["scanFieldSize"]);
                //然后再用单个宽去计算出高是多少
                double d_scanFieldSize_height = 0;
                if (d_scanFieldSize_width != 0)
                    d_scanFieldSize_height = (d_scanFieldSize_width / Convert.ToDouble(imageWidth)) * imageHeight;

                ret_rect.Width = (int)d_scanFieldSize_width;
                ret_rect.Height = (int)d_scanFieldSize_height;
            }
            ///-----------because all the  fields 's height/width=0.75 so here we make an enforce. gsp add at 2019/10/31
            ///sometimes the gbfields are not conform to this for the cuting and merging operation.
            //if (ret_rect.Height / ret_rect.Width != 0.75f)
            //{
            //    ret_rect = new Rectangle(ret_rect.X, ret_rect.Y, ret_rect.Width, (int)(ret_rect.Width * 0.75f));
            //}
            return ret_rect;
        }



        #endregion

        #region 电镜操作相关方法
        /// <summary>
        /// 连接电镜,分布图使用
        /// </summary>
        public void ConnectToSEM()
        {
           
         
            log.Trace("(Connection_ForDrawDistrbutionImageAndBSE)" + "Connect to SEM");
            if (!m_SEMConnectionState)
            {


                //和电镜建立通讯连接
                m_SEMConnectionState = m_cfun.Connect();
             
                log.Trace("(Connection_ForDrawDistrbutionImageAndBSE)" + "Connect to SEM" + ":--" + m_SEMConnectionState + "---");

        
            }
            else
            {
             
                log.Trace("(Connection_ForDrawDistrbutionImageAndBSE)" + ":allready connected, state:" + m_SEMConnectionState);
                //断开电镜连接
            }
        }
        public void DisConnectSEM()
        {
            m_SEMConnectionState = false;
            m_cfun.DisConnect();
        }


            /// <summary>
            /// 移动电镜到指定的X,Y坐标上，R坐标使用原先的值进行移动
            /// </summary>
            /// <param name="PositionX"></param>
            /// <param name="PositionY"></param>
            public void MoveSemToPointXY(double in_PositionX, double in_PositionY)
        {
            
            log.Trace("Begin MoveSemToPointXY:(" +in_PositionX.ToString()+","+in_PositionY.ToString()+")");

            //首先获取电镜当前的位置，并记录原R值
            double ls_PositionX = 0;
            double ls_PositionY = 0;
            double ls_PositionR = 0;

            if (m_SEMConnectionState)
            {
                m_cfun.GetSemPositionXY(ref ls_PositionX, ref ls_PositionY, ref ls_PositionR);
            }
            else
            {
                log.Error("Failed to GetSemPositionXY");
                return;
            }

            if (m_SEMConnectionState)
            {
                m_cfun.MoveSEMToPoint(new Point((int)in_PositionX, (int)in_PositionY), ls_PositionR);
            }
           
        }

      

       
        #endregion

        #region //--------------------------------------颗粒分布图相关部份---------------------------------------------------------------------
        /// <summary>
        /// 传入颗粒的tagid和fieldid,来获取该颗粒下对应的xray数据
        /// </summary>
        /// <param name="in_clr_tagid"></param>
        /// <param name="in_clr_fieldid"></param>
        /// <param name="Search_xray"></param>
        /// <param name="Analysis_xray"></param>
        public void GetXrayByParticleTagIDAndFieldID_ForDrawDistrbutionImageAndBSE(int in_clr_tagid, int in_clr_fieldid, out uint[] Search_xray, out uint[] Analysis_xray, out int xray_id, out List<Element> list_celementchemistryclr)
        {

            Search_xray = new uint[2000];
            Analysis_xray = new uint[2000];
            xray_id = 0;
            list_celementchemistryclr = new List<Element>();

            //防止为空校验判断
            if (resultFile.List_OTSField == null)
                return;
            Particle particle = resultFile.List_OTSField.Find(x => x.FieldID == in_clr_fieldid).ParticleList.Find(x => x.ParticleId == in_clr_tagid);
            var tmpPart = new ParticleData(resultFile.FilePath).GetParticleXrayDataByFidAndPid(Convert.ToString(particle.FieldId), Convert.ToString(particle.XrayId));
            if (tmpPart != null)
            {
                particle.XRayData = tmpPart.XRayData;
                if (particle.XrayId > -1)
                {
                    for (int i = 0; i < 2000; i++)
                    {
                        Analysis_xray[i] = BitConverter.ToUInt32(particle.XRayData, i * 4);
                    }

                    Search_xray = Analysis_xray;
                    xray_id = particle.XrayId;
                    list_celementchemistryclr = particle.ElementList;
                }

            }
           

        }

        public bool DeleteParticlesFromLibrary(int in_clr_tagid, int in_clr_fieldid)
        {
            bool DoesItExist = false;
            for (int i=1;i<201;i++)
            {
                if (System.IO.Directory.Exists(resultFile.FilePath + "\\FIELD_FILES\\Backups"+i.ToString()))
                {
                    DoesItExist = true;
                    break;
                }
            }
            if (!DoesItExist)
            {
                //备份数据库
                BackupDatabase();
            }
            DoesItExist = false;

            //防止为空校验判断
            if (resultFile.List_OTSField == null)
                return false;
            Particle particle = resultFile.List_OTSField.Find(x => x.FieldID == in_clr_fieldid).ParticleList.Find(x => x.ParticleId == in_clr_tagid);
            if (new ParticleData(resultFile.FilePath).DeleteFromData(Convert.ToString(particle.FieldId), Convert.ToString(particle.XrayId)))
            {
                
                return true;
            }else

            {
                return false;
            }
        }

        public bool BackupDatabase()
        {
            //创建备份数据库文件夹
            string sourcePath = resultFile.FilePath + "\\FIELD_FILES\\Inclusion.db";//源文件路径
            string sourceName = "Inclusion.db";//源文件名称
            string folderPath = resultFile.FilePath + "\\FIELD_FILES\\Backups";//目标文件夹
            string Fields = "";
            for (int i = 1; i < 201; i++)
            {
                if (System.IO.Directory.Exists(folderPath + i.ToString()))
                {
                    Fields = folderPath + i.ToString();
                    break;
                }
                else
                {
                    System.IO.Directory.CreateDirectory(folderPath + i.ToString());
                    Fields = folderPath + i.ToString();
                    break;
                }
            }
            if (Fields == "")
            {
                return false;
            }
            //复制数据库文件
            string targetPath = Path.Combine(Fields, sourceName);
            FileInfo file = new FileInfo(sourcePath);
            if (file.Exists)
            {
                file.CopyTo(targetPath, true);
            }

            return true;
        }
        /// <summary>
        /// 传入所有的物理field坐标点，和单个物理field的宽高，返回所有field的左上角位置，和整个field组成的rect大小
        /// </summary>
        /// <param name="in_list_point"></param>
        /// <param name="in_width"></param>
        /// <param name="in_height"></param>
        /// <returns></returns>
        public Rectangle GetWlRectTopLeftAndRect(List<Point> in_list_point, int in_width, int in_height)
        {
            //分别获取整个rect的xy最小值和最大值
            int i_rect_x_min = 100000000;
            int i_rect_y_min = 100000000;
            int i_rect_x_max = -100000000;
            int i_rect_y_max = -100000000;

            for (int i = 0; i < in_list_point.Count; i++)
            {
                if (i_rect_x_min > in_list_point[i].X)
                    i_rect_x_min = in_list_point[i].X;

                if (i_rect_y_min > in_list_point[i].Y)
                    i_rect_y_min = in_list_point[i].Y;

                if (i_rect_x_max < in_list_point[i].X)
                    i_rect_x_max = in_list_point[i].X;

                if (i_rect_y_max < in_list_point[i].Y)
                    i_rect_y_max = in_list_point[i].Y;
            }

            Rectangle ret_rect = new Rectangle(i_rect_x_min, i_rect_y_min,
    i_rect_x_max - i_rect_x_min, i_rect_y_max - i_rect_y_min);

            return ret_rect;
        }

        /// <summary>
        /// 根据Field的ID，来获取Field列表中对应FIeld的OTS 坐标
        /// </summary>
        /// <param name="in_fieldid"></param>
        /// <returns></returns>
        public Point GetOTSPointByFieldID(List<DisplayField> in_list_dfield, int in_fieldid)
        {
            Point ret_point = new Point(0, 0);
            for (int i = 0; i < in_list_dfield.Count; i++)
            {
                //这里TagID先代表的是底层返回的ID
                if (in_list_dfield[i].FieldID == in_fieldid.ToString())
                {
                    ret_point = new Point(Convert.ToInt32(in_list_dfield[i].OTSCoordinatePos.X), Convert.ToInt32(in_list_dfield[i].OTSCoordinatePos.Y));
                }
            }

            return ret_point;
        }


        /// <summary>
        /// 将OTS坐标转换为Sem 坐标
        /// </summary>
        /// <param name="POTSCoord"></param>
        /// <returns></returns>
        public Point ChangeOTSToSemCoord(Point POTSCoord)
        {
            //first if m_semstagedata is null to get stage inforation
            Convert.ToDouble(((Dictionary<string, object>)resultFile.ResultInfo["SEMStageData"])["scanFieldSize"]);
            //after obtaining stage info,calc stage point data
            Point ret_SEM_point = new Point();

            // get center point, um
            long xStart = Convert.ToInt64(((Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)resultFile.ResultInfo["SEMStageData"])["Members"])["XAxis"])["start"]);
            long xEnd = Convert.ToInt64(((Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)resultFile.ResultInfo["SEMStageData"])["Members"])["XAxis"])["end"]);

            long xCenter = (xStart + xEnd) / 2;

            long yStart = Convert.ToInt64(((Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)resultFile.ResultInfo["SEMStageData"])["Members"])["YAxis"])["start"]);
            long yEnd = Convert.ToInt64(((Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)resultFile.ResultInfo["SEMStageData"])["Members"])["YAxis"])["end"]);

            long yCenter = (yStart + yEnd) / 2;

            // delte = SEM - OTSa
            long deltex = xCenter - 0;
            long deltey = yCenter - 0;
            int xdir = Convert.ToInt32(((Dictionary<string, object>)resultFile.ResultInfo["SEMStageData"])["xAxisDir"]);
            int ydir = Convert.ToInt32(((Dictionary<string, object>)resultFile.ResultInfo["SEMStageData"])["yAxisDir"]);
            if (xdir == (int)OTS_X_AXIS_DIRECTION.LEFT_TOWARD)
            {
                ret_SEM_point.X = -1 * (POTSCoord.X - Convert.ToInt32(deltex));
            }
            else if (xdir == (int)OTS_X_AXIS_DIRECTION.RIGHT_TOWARD)
            {
                ret_SEM_point.X = POTSCoord.X + Convert.ToInt32(deltex);
            }

            if (ydir == (int)OTS_Y_AXIS_DIRECTION.UP_TOWARD)
            {
                ret_SEM_point.Y = POTSCoord.Y + Convert.ToInt32(deltey);
            }
            else if (ydir == (int)OTS_Y_AXIS_DIRECTION.DOWN_TOWARD)
            {
                ret_SEM_point.Y = -1 * (POTSCoord.Y - Convert.ToInt32(deltey));
            }

            return ret_SEM_point;
        }






        #endregion
        /// <summary>
        /// 判断该点是否在多边形的范围内
        /// </summary>
        /// <param name="inPoints"></param>
        /// <param name="WhetherPoint"></param>
        /// <returns></returns>
        public bool WhetherInRange(DisplayParticle Part,/*PointF[] inPoints,*/ Point WhetherPoint)
        {
            var rect = Part.Rect;
            if ((rect.Left < WhetherPoint.X && WhetherPoint.X < rect.Right) && (rect.Top < WhetherPoint.Y && WhetherPoint.Y < rect.Bottom))
            {
                var itm = (BaseObject)Part;
                itm.GPath = Part.GetRegionFromDSegments();
                PointF[] inPoints = itm.GPath.PathPoints;
                bool b_inrange = false;
                GraphicsPath myGraphicsPath = new GraphicsPath();
                Region myRegion = new Region();
                myGraphicsPath.Reset();

                myGraphicsPath.AddPolygon(inPoints);
                myRegion.MakeEmpty();
                myRegion.Union(myGraphicsPath);
                //返回判断点是否在多边形里
                b_inrange = myRegion.IsVisible(WhetherPoint);
                return b_inrange;
            }
            else
            {
                return false;

            }

        }
        public bool WhetherInRange(RectangleF rec,PointF[] inPoints, Point WhetherPoint)
        {
            var rect = rec;
            if ((rect.Left < WhetherPoint.X && WhetherPoint.X < rect.Right) && (rect.Top < WhetherPoint.Y && WhetherPoint.Y < rect.Bottom))
            {
                //var itm = (BaseObject)Part;
                //PointF[] inPoints = itm.GPath.PathPoints;
                bool b_inrange = false;
                GraphicsPath myGraphicsPath = new GraphicsPath();
                Region myRegion = new Region();
                myGraphicsPath.Reset();

                myGraphicsPath.AddPolygon(inPoints);
                myRegion.MakeEmpty();
                myRegion.Union(myGraphicsPath);
                //返回判断点是否在多边形里
                b_inrange = myRegion.IsVisible(WhetherPoint);
                return b_inrange;
            }
            else
            {
                return false;

            }

        }

        /// <summary>
        /// 判断该点是否在多边形的范围内的float版本重载
        /// </summary>
        /// <param name="inPoints"></param>
        /// <param name="WhetherPoint"></param>
        /// <returns></returns>
        public  bool WhetherInRange(DisplayParticle Part,/* PointF[] inPoints, */PointF WhetherPoint)
        {
            var rect = Part.Rect;
            if ((rect.Left < WhetherPoint.X && WhetherPoint.X < rect.Right) && (rect.Top < WhetherPoint.Y && WhetherPoint.Y < rect.Bottom))
            {
                var itm = (BaseObject)Part;
                PointF[] inPoints = itm.GPath.PathPoints;
                bool b_inrange = false;
                GraphicsPath myGraphicsPath = new GraphicsPath();
                Region myRegion = new Region();
                myGraphicsPath.Reset();

                myGraphicsPath.AddPolygon(inPoints);
                myRegion.MakeEmpty();
                myRegion.Union(myGraphicsPath);
                //返回判断点是否在多边形里
                b_inrange = myRegion.IsVisible(WhetherPoint);
                return b_inrange;
            }
            else
            {
                return false;
            }
        }


        #region 颗粒分割功能方法
        /// <summary>
        /// 获取线段与矩形的两个交点
        /// </summary>
        /// <param name="line1S"></param>
        /// <param name="line1E"></param>
        /// <param name="rectangle"></param>
        /// <param name="pointList"></param>
        /// <returns></returns>
        public bool GetInterBetweenLinesAndRect(Point line1S, Point line1E, RectangleF rectangle, ref List<Point> pointList)
        {
            try
            {
                PointF pointF = new PointF(-1, -1);
                Rect rect = new Rect();
                rect.X = m_ParticleSegmentation.ParticleData.RectLeft;
                rect.Y = m_ParticleSegmentation.ParticleData.RectTop;
                rect.Width = m_ParticleSegmentation.ParticleData.RectWidth;
                rect.Height = m_ParticleSegmentation.ParticleData.RectHeight;
                float border = 0;

                if (GetInterBetweenTwoLines(line1S, line1E, new PointF(rectangle.Left, rectangle.Top), new PointF(rectangle.Right, rectangle.Top), ref pointF))
                {
                    border = (pointF.X - rectangle.Left) / (rectangle.Right - rectangle.Left);
                    pointList.Add(new Point((int)(rect.X + rect.Width * border), rect.Y));
                }

                if (GetInterBetweenTwoLines(line1S, line1E,
                    new PointF(rectangle.Left, rectangle.Bottom), new PointF(rectangle.Right, rectangle.Bottom), ref pointF))
                {
                    border = (pointF.X - rectangle.Left) / (rectangle.Right - rectangle.Left);
                    pointList.Add(new Point((int)(rect.X + rect.Width * border), rect.Y + rect.Height));
                }

                if (GetInterBetweenTwoLines(line1S, line1E,
                    new PointF(rectangle.Left, rectangle.Top), new PointF(rectangle.Left, rectangle.Bottom), ref pointF))
                {
                    border = (pointF.Y - rectangle.Top) / (rectangle.Bottom - rectangle.Top);
                    pointList.Add(new Point(rect.X, (int)(rect.Y + rect.Height * border)));
                }

                if (GetInterBetweenTwoLines(line1S, line1E,
                    new PointF(rectangle.Right, rectangle.Top), new PointF(rectangle.Right, rectangle.Bottom), ref pointF))
                {
                    border = (pointF.Y - rectangle.Top) / (rectangle.Bottom - rectangle.Top);
                    pointList.Add(new Point(rect.X + rect.Width, (int)(rect.Y + rect.Height * border)));
                }

                if (pointList.Count == 2)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                log.Trace("(GetSplitPartFun)" + ex);
                return false;
            }
        }

        /// <summary>
        /// 获取分离颗粒方法
        /// </summary>
        /// <param name="startPoint"></param>
        /// <param name="endPoint"></param>
        /// <returns></returns>
        public bool GetSplitPartFun(Point startPoint, Point endPoint)
        {
            try
            {
                CImageHandler m_ImagePro = new CImageHandler();
                Particle particle1 = (Particle)CloneObject(m_ParticleSegmentation.ParticleData);
                Particle particle2 = (Particle)CloneObject(m_ParticleSegmentation.ParticleData);
                Dictionary<string, object> sampleMembers = ((Dictionary<string, object>)((Dictionary<string, object>)resultFile.ResultInfo["Sample"])["Members"]);
                Dictionary<string, object> imageScanParam = (Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)sampleMembers["MsrParams"])["Members"])["ImageScanParam"];
                double d_scanFieldSize_width = Convert.ToDouble(((Dictionary<string, object>)resultFile.ResultInfo["SEMStageData"])["scanFieldSize"]);
                string ImageResolution = imageScanParam["ImageResolution"].ToString();
                int width = int.Parse(ImageResolution.Split('_')[1]);
                int height = int.Parse(ImageResolution.Split('_')[2]);
                double dPixelSize = d_scanFieldSize_width / width;

                using (Mat mat = new Mat(height, width, MatType.CV_8UC1, Scalar.Black))//黑色底图
                using (Mat labelMat = new Mat())
                using (Mat stats = new Mat())
                using (Mat centroids = new Mat())
                using (Mat matBse = new Mat(resultFile.List_OTSField[particle1.FieldId].FieldImage, ImreadModes.Grayscale))
                {
                    foreach (Segment segment in m_ParticleSegmentation.ParticleData.SegmentList)
                    {
                        Cv2.Line(mat, new OpenCvSharp.Point(segment.Start, segment.Height), new OpenCvSharp.Point(segment.Start + segment.Length, segment.Height), Scalar.White, 1, LineTypes.AntiAlias);
                    }
                    //寻找坐标点
                    List<Point> points1 = new List<Point>();
                    List<Point> points2 = new List<Point>();
                    List<int> aveGray1 = new List<int>();
                    List<int> aveGray2 = new List<int>();
                    for (int k = 0; k < mat.Height; k++)
                    {
                        for (int j = 0; j < mat.Width; j++)
                        {
                            if (mat.Get<int>(k, j) != 0)
                            {
                                int side = (startPoint.X - j) * (endPoint.Y - k) - (startPoint.Y - k) * (endPoint.X - j);
                                if (side >= 0)//区分像素位置
                                {
                                    points1.Add(new Point(j, k));
                                    aveGray1.Add(matBse.Get<byte>(k, j));
                                }
                                else
                                {
                                    points2.Add(new Point(j, k));
                                    aveGray2.Add(matBse.Get<byte>(k, j));
                                }
                            }
                        }
                    }
                    //处理Segment
                    List<COTSSegmentClr> SegmentClrList1 = new List<COTSSegmentClr>();
                    List<COTSSegmentClr> SegmentClrList2 = new List<COTSSegmentClr>();
                    List<Segment> SegmentList1 = new List<Segment>();
                    List<Segment> SegmentList2 = new List<Segment>();
                    GetSegment(points1, SegmentClrList1, ref SegmentList1);
                    GetSegment(points2, SegmentClrList2, ref SegmentList2);

                    //颗粒一
                    Cv2.Threshold(mat, mat, 0, 0, ThresholdTypes.Binary);
                    foreach (Segment segment in SegmentList1)
                    {
                        Cv2.Line(mat, new OpenCvSharp.Point(segment.Start, segment.Height), new OpenCvSharp.Point(segment.Start + segment.Length, segment.Height), Scalar.White, 1, LineTypes.AntiAlias);
                    }
                    Cv2.ConnectedComponentsWithStats(mat, labelMat, stats, centroids, PixelConnectivity.Connectivity8);

                    CopyToPart(particle1, SegmentList1, SegmentClrList1, aveGray1, stats, centroids, dPixelSize);

                    //颗粒二
                    Cv2.Threshold(mat, mat, 0, 0, ThresholdTypes.Binary);
                    foreach (Segment segment in SegmentList2)
                    {
                        Cv2.Line(mat, new OpenCvSharp.Point(segment.Start, segment.Height), new OpenCvSharp.Point(segment.Start + segment.Length, segment.Height), Scalar.White, 1, LineTypes.AntiAlias);
                    }
                    Cv2.ConnectedComponentsWithStats(mat, labelMat, stats, centroids, PixelConnectivity.Connectivity8);

                    CopyToPart(particle2, SegmentList2, SegmentClrList2, aveGray2, stats, centroids, dPixelSize);

                    if (!SaveToDb(particle1, particle2))
                    {
                        log.Trace("(GetSplitPartFun) SaveToDb Faild");
                        return false;
                    }
                }

                return true;
            }
            catch (Exception ex)
            {
                log.Trace("(GetSplitPartFun)" + ex);
                return false;
            }
        }

        /// <summary>
        /// 拷贝颗粒数据
        /// </summary>
        /// <param name="particle"></param>
        /// <param name="segments"></param>
        /// <param name="SegmentClrList"></param>
        /// <param name="aveGray"></param>
        /// <param name="stats"></param>
        /// <param name="centroids"></param>
        /// <param name="dPixelSize"></param>
        private void CopyToPart(Particle particle, List<Segment> segments, List<COTSSegmentClr> SegmentClrList, List<int> aveGray, Mat stats, Mat centroids, double dPixelSize)
        {
            CImageHandler m_ImagePro = new CImageHandler();
            COTSParticleClr part = new COTSParticleClr();
            part.SetArea(stats.At<int>(1, 4) * dPixelSize * dPixelSize);
            part.SetParticleRect(new Rectangle(stats.At<int>(1, 0), stats.At<int>(1, 1), stats.At<int>(1, 2), stats.At<int>(1, 3)));
            part.GetFeature().SetSegmentsList(SegmentClrList, false);
            m_ImagePro.CalParticleImageProp(part, dPixelSize);

            particle.SegmentList = segments;
            particle.SegmentNum = segments.Count;
            particle.AveGray = (int)aveGray.Average();
            particle.RectLeft = stats.At<int>(1, 0);
            particle.RectTop = stats.At<int>(1, 1);
            particle.RectWidth = stats.At<int>(1, 2);
            particle.RectHeight = stats.At<int>(1, 3);
            particle.Area = stats.At<int>(1, 4) * dPixelSize * dPixelSize;
            particle.PosX = (int)centroids.At<double>(1, 0);
            particle.PosY = (int)centroids.At<double>(1, 1);
            particle.DFERET = part.GetFeretDiameter();
            particle.DMAX = part.GetDMAX();
            particle.DMIN = part.GetDMIN();
            particle.DPERP = part.GetDMPERP();
            particle.PERIMETER = part.GetDPRIMETER();
            particle.ORIENTATION = part.GetORIENTATION();
            particle.DINSCR = part.GetDINSCR();
            particle.DMEAN = part.GetDMEAN();
            particle.DELONG = part.GetDELONG();
        }

        /// <summary>
        /// 保存数据库
        /// </summary>
        /// <param name="particle1"></param>
        /// <param name="particle2"></param>
        /// <returns></returns>
        public bool SaveToDb(Particle particle1, Particle particle2)
        {
            //初始化
            SQLiteHelper sQLiteHelper = new SQLiteHelper(resultFile.FilePath + "\\FIELD_FILES\\Inclusion.db");
            sQLiteHelper.GetDBConnection();
            sQLiteHelper.BeginTransaction();

            //修改Segment表
            if (particle1.SegmentList.Count == 0 || particle2.SegmentList.Count == 0)
            {
                return false;
            }
            int SegmentCount = sQLiteHelper.ExecuteNewPartIdForTransaction() + 1;
            if (!sQLiteHelper.ExecuteSegmentForTransaction(particle1, particle2, SegmentCount))//修改Segment表
            {
                return false;
            }
            if (!sQLiteHelper.ExecuteXrayForTransaction(particle1, particle2, SegmentCount))//修改XRayData和PoxXrayInfo表
            {
                return false;
            }
            if (!sQLiteHelper.ExecuteIncAForTransaction(particle1, particle2, SegmentCount))//修改IncAData表
            {
                return false;
            }
            sQLiteHelper.CommitTransaction();
            return true;
        }
        /// <summary>
        /// 线段与矩形是否相交
        /// </summary>
        /// <param name="linePointX1"></param>
        /// <param name="linePointY1"></param>
        /// <param name="linePointX2"></param>
        /// <param name="linePointY2"></param>
        /// <param name="rectangleLeftTopX"></param>
        /// <param name="rectangleLeftTopY"></param>
        /// <param name="rectangleRightBottomX"></param>
        /// <param name="rectangleRightBottomY"></param>
        /// <returns></returns>
        public bool isLineIntersectRectangle(float linePointX1,
                                          float linePointY1,
                                        float linePointX2,
                                         float linePointY2,
                                         float rectangleLeftTopX,
                                          float rectangleLeftTopY,
                                          float rectangleRightBottomX,
                                          float rectangleRightBottomY)
        {
            float lineHeight = linePointY1 - linePointY2;
            float lineWidth = linePointX2 - linePointX1;  // 计算叉乘 
            float c = linePointX1 * linePointY2 - linePointX2 * linePointY1;
            if ((lineHeight * rectangleLeftTopX + lineWidth * rectangleLeftTopY + c >= 0 && lineHeight * rectangleRightBottomX + lineWidth * rectangleRightBottomY + c <= 0)
                || (lineHeight * rectangleLeftTopX + lineWidth * rectangleLeftTopY + c <= 0 && lineHeight * rectangleRightBottomX + lineWidth * rectangleRightBottomY + c >= 0)
                || (lineHeight * rectangleLeftTopX + lineWidth * rectangleRightBottomY + c >= 0 && lineHeight * rectangleRightBottomX + lineWidth * rectangleLeftTopY + c <= 0)
                || (lineHeight * rectangleLeftTopX + lineWidth * rectangleRightBottomY + c <= 0 && lineHeight * rectangleRightBottomX + lineWidth * rectangleLeftTopY + c >= 0))
            {

                if (rectangleLeftTopX > rectangleRightBottomX)
                {
                    float temp = rectangleLeftTopX;
                    rectangleLeftTopX = rectangleRightBottomX;
                    rectangleRightBottomX = temp;
                }
                if (rectangleLeftTopY < rectangleRightBottomY)
                {
                    float temp1 = rectangleLeftTopY;
                    rectangleLeftTopY = rectangleRightBottomY;
                    rectangleRightBottomY = temp1;
                }
                if ((linePointX1 < rectangleLeftTopX && linePointX2 < rectangleLeftTopX)
                    || (linePointX1 > rectangleRightBottomX && linePointX2 > rectangleRightBottomX)
                    || (linePointY1 > rectangleLeftTopY && linePointY2 > rectangleLeftTopY)
                    || (linePointY1 < rectangleRightBottomY && linePointY2 < rectangleRightBottomY))
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
            else
            {
                return false;
            }

        }
        /// <summary>
        /// 求一个线段与另一个线段的交点
        /// </summary>
        /// <param name="line1S"></param>
        /// <param name="line1E"></param>
        /// <param name="line2S"></param>
        /// <param name="line2E"></param>
        /// <param name="interPoint"></param>
        /// <returns>-1：不存在交点；1：存在一个交点；2：存在无穷多个交点（重合或部分重合）</returns>
        public bool GetInterBetweenTwoLines(PointF line1S, PointF line1E,
            PointF line2S, PointF line2E, ref PointF interPoint)
        {
            int status = -1;
            // 判断两条直线各自的矩形包围盒的X与Y的值范围
            float line1Xmin = line1S.X < line1E.X ? line1S.X : line1E.X,
                line1Xmax = line1S.X > line1E.X ? line1S.X : line1E.X,
                line1Ymin = line1S.Y < line1E.Y ? line1S.Y : line1E.Y,
                line1Ymax = line1S.Y > line1E.Y ? line1S.Y : line1E.Y,
                line2Xmin = line2S.X < line2E.X ? line2S.X : line2E.X,
                line2Xmax = line2S.X > line2E.X ? line2S.X : line2E.X,
                line2Ymin = line2S.Y < line2E.Y ? line2S.Y : line2E.Y,
                line2Ymax = line2S.Y > line2E.Y ? line2S.Y : line2E.Y;
            if (line1S.X - line1E.X == 0)
            {
                // 两条线都垂直于X轴
                if (line2S.X - line2E.X == 0)
                {
                    if (line1S.X != line2S.X) status = -1;
                    else if ((line1Ymin > line2Ymax) || (line1Ymax < line2Ymin)) status = -1;
                    else if (line1Ymin == line2Ymax)
                    {
                        interPoint = new PointF(line1S.X, line1Ymin); status = 1;
                    }
                    else if (line1Ymax == line2Ymin)
                    {
                        interPoint = new PointF(line1S.X, line1Ymax); status = 1;
                    }
                    else status = 2;
                }
                // line1垂直于X轴，line2不垂直于X轴
                else
                {
                    float slope = (line2S.Y - line2E.Y) / (line2S.X - line2E.X);
                    float offset = line2S.Y - slope * line2S.X;
                    float newX = line1S.X, newY = slope * newX + offset;
                    if (newX >= line2Xmin && newX <= line2Xmax && newY >= line1Ymin && newY <= line1Ymax
                        && newY >= line2Ymin && newY <= line2Ymax)
                    {
                        interPoint = new PointF(newX, newY); status = 1;
                    }
                }
            }
            else
            {
                // line1不垂直于X轴，line2垂直于X轴
                if (line2S.X - line2E.X == 0)
                {
                    float slope = (line1S.Y - line1E.Y) / (line1S.X - line1E.X);
                    float offset = line1S.Y - slope * line1S.X;
                    float newX = line2S.X, newY = slope * newX + offset;
                    if (newX >= line1Xmin && newX <= line1Xmax && newY >= line1Ymin && newY <= line1Ymax
                        && newY >= line2Ymin && newY <= line2Ymax)
                    {
                        interPoint = new PointF(newX, newY); status = 1;
                    }
                }
                // line1和line2都不垂直于X轴
                else
                {
                    float slope1 = (line1S.Y - line1E.Y) / (line1S.X - line1E.X);
                    float offset1 = line1S.Y - slope1 * line1S.X;
                    float slope2 = (line2S.Y - line2E.Y) / (line2S.X - line2E.X);
                    float offset2 = line2S.Y - slope2 * line2S.X;
                    // 如果两条直线平行
                    if (slope1 == slope2)
                    {
                        if (offset1 != offset2) status = -1;
                        else if (line1Xmax == line2Xmin)
                        {
                            interPoint = new PointF(line1Xmax, line1Xmax * slope1 + offset1); status = 1;
                        }
                        else if (line1Xmin == line2Xmax)
                        {
                            interPoint = new PointF(line1Xmin, line1Xmin * slope1 + offset1); status = 1;
                        }
                        else if (line1Xmax < line2Xmin || line1Xmin > line2Xmax) status = -1;
                        else status = 2;
                    }
                    else
                    {
                        float newX = (offset2 - offset1) / (slope1 - slope2), newY = newX * slope1 + offset1;
                        if (newX >= line1Xmin && newX <= line1Xmax && newX >= line2Xmin && newX <= line2Xmax)
                        {
                            interPoint = new PointF(newX, newY); status = 1;
                        }
                    }
                }
            }

            if (status == 1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 获取Segment信息
        /// </summary>
        /// <param name="points"></param>
        /// <param name="SegmentClrList"></param>
        /// <param name="SegmentList"></param>
        public void GetSegment(List<Point> points, List<COTSSegmentClr> SegmentClrList, ref List<Segment> SegmentList)
        {
            List<int> segmentStart = new List<int>();
            List<int> segmentHeight = new List<int>();
            List<int> segmentLength = new List<int>();
            FindSegment(points, ref segmentStart, ref segmentHeight, ref segmentLength);
            for (int i = 0; i < segmentLength.Count; i++)
            {
                COTSSegmentClr seg = new COTSSegmentClr();
                seg.SetStart(segmentStart[i]);
                seg.SetHeight(segmentHeight[i]);
                seg.SetLength(segmentLength[i]);
                SegmentClrList.Add(seg);
                Segment segment = new Segment();
                segment.Start = segmentStart[i];
                segment.Height = segmentHeight[i];
                segment.Length = segmentLength[i];
                segment.SegmentNum = segmentLength.Count;
                segment.SegmentId = i;
                segment.FieldId = m_ParticleSegmentation.ParticleData.FieldId;
                segment.XRayId = m_ParticleSegmentation.ParticleData.XrayId;
                segment.ParticleId = m_ParticleSegmentation.ParticleData.ParticleId;
                SegmentList.Add(segment);
            }
        }

        /// <summary>
        /// 寻找segment方法
        /// </summary>
        public void FindSegment(List<Point> point_list_final, ref List<int> segmentStart, ref List<int> segmentHeight, ref List<int> segmentLength)
        {
            int flag = 0;
            point_list_final.Sort(my_sort);//排序

            for (int k = 0; k < point_list_final.Count(); k++)
            {
                if (k == 0 && k != point_list_final.Count() - 1)//第一个颗粒
                {
                    flag++;
                    segmentStart.Add(point_list_final[k].X);
                    segmentHeight.Add(point_list_final[k].Y);
                }
                else if (k == 0 && k == point_list_final.Count() - 1)//只有一个颗粒
                {
                    segmentStart.Add(point_list_final[k].X);
                    segmentHeight.Add(point_list_final[k].Y);
                    segmentLength.Add(1);
                }
                else if (k == point_list_final.Count() - 1)//最后一个颗粒
                {
                    flag++;
                    segmentLength.Add(flag);
                }
                else if (point_list_final[k].Y == point_list_final[k - 1].Y && point_list_final[k].X == point_list_final[k - 1].X + 1)//同行连续
                {
                    flag++;
                }
                else if (point_list_final[k].Y == point_list_final[k - 1].Y && point_list_final[k].X != point_list_final[k - 1].X + 1)//同行隔断
                {
                    segmentLength.Add(flag);
                    flag = 1;
                    segmentStart.Add(point_list_final[k].X);
                    segmentHeight.Add(point_list_final[k].Y);
                }
                else if (point_list_final[k].Y != point_list_final[k - 1].Y)//不同行
                {
                    segmentLength.Add(flag);
                    flag = 1;
                    segmentStart.Add(point_list_final[k].X);
                    segmentHeight.Add(point_list_final[k].Y);
                }
            }
        }

        /// <summary>
        /// 排序方法
        /// </summary>
        /// <param name="p1"></param>
        /// <param name="p2"></param>
        /// <returns></returns>
        private int my_sort(Point p1, Point p2)
        {
            return p1.Y == p2.Y ? p1.X.CompareTo(p2.X) : p1.Y.CompareTo(p2.Y); //升序排序
        }
        public object CloneObject(object obj)
        {
            using (MemoryStream stream = new MemoryStream())
            {
                BinaryFormatter formatter = new BinaryFormatter();
                stream.Position = 0;
                formatter.Serialize(stream, obj);
                stream.Position = 0;
                return formatter.Deserialize(stream);
            }
        }
        #endregion
    }
}