WingAIDiagnosisService/Carotid/MathTools/MathTools3D.cs



using System;
using System.Collections.Generic;
using System.Drawing;
using WingAIDiagnosisService.Carotid.CarotidInterFacesData;
using WingAIDiagnosisService.Carotid.Utilities;
using WingServerCommon.Log;

namespace WingAIDiagnosisService.Carotid.MathTools
{
   

    /// <summary>
    /// 计算切面的三个点
    /// </summary>
    public struct One2DPlaneThreeBasic3DPoints
    {
        public Vector3D ZeroPoint;
        public Vector3D XAxisPoint;
        public Vector3D YAxisPoint;
    }

    /// <summary>
    /// 计算切面的三个点
    /// </summary>
    public struct One3DPlaneThreeBasicPoints
    {
        public Vector3D PointA;
        public Vector3D PointB;
        public Vector3D PointC;
    }

    /// <summary>
    /// 平面方程Ax+By+CZ+D=0;
    /// </summary>
    public struct PlaneEquation
    {
        public double A;
        public double B;
        public double C;
        public double D;
    }

    /// <summary>
    /// 直线方程Ax+By+C=0
    /// </summary>
    public struct LineEquation
    {
        public double A;
        public double B;
        public double C;
    }

    /// <summary>
    /// 三维空间线段
    /// </summary>
    public struct LineSegment3I
    {
        //线段开始的端点
        public Vector3I EndPointBegin;
        //线段结束的端点
        public Vector3I EndPointEnd;
    }

    /// <summary>
    /// 三维坐标变换
    /// </summary>
    public struct CoordinateTransformation3D
    {
        public double[] RotationMatrix;
        public double[] TranslationMatrix;
    }

    /// <summary>
    /// 切片端点的世界点和图像点，cosA是图像点向量与图像X轴的夹角余弦值
    /// </summary>
    public struct EndPointStruct
    {
        public Vector3D EndPoint3D;
        public Vector2I EndPoint2I;
        public double CosA;
        //分子
        public long Molecule;
        //分母
        public long Denominator;
    }

    public class MathTools3D
    {

        /// <summary>
        /// 计算是否要翻转切面
        /// </summary>
        /// <param name="points"></param>
        /// <returns></returns>
        public  static bool GetIsFlip(IList<Vector3D> points,ModelSize modelSize)
        {
            //变换成java端坐标系temp=y，y=z，z=-temp
            var planeEquation = MathTools3D.GetPlaneEquation(ChangeToJavaCoordinate(points[0]),
                                                                                              ChangeToJavaCoordinate(points[1]),
                                                                                              ChangeToJavaCoordinate(points[2]));

            var vector1 = MathTools3D.GetVector(points[2], points[1]);
            var vector2 = MathTools3D.GetVector(points[0], points[1]);
            var crossVect = CrossVectors(vector1, vector2);
            int direction = crossVect.X > 0 ? 1 : -1;
            if (direction * planeEquation.A > 0)
            {
                planeEquation = new PlaneEquation()
                {
                    A = -planeEquation.A,
                    B = -planeEquation.B,
                    C = -planeEquation.C,
                    D = -planeEquation.D,
                };
            }
            var centePoint1 = ChangeToJavaCoordinate(new Vector3D(modelSize.ModelLengthX, modelSize.ModelLengthY, modelSize.ModelLengthZ));
            var centePoint = new Vector3D(Math.Abs(centePoint1.X / 2), Math.Abs(centePoint1.Y / 2), Math.Abs(centePoint1.Z / 2));
            //判断模型中心点在切面的左边还是右边
            var res = planeEquation.A * centePoint.X + planeEquation.B * centePoint.Y + planeEquation.C * centePoint.Z + planeEquation.D;
            if (res > 0)
            {
                return true;
            }
            return false;
        }

        private static Vector3D ChangeToJavaCoordinate(Vector3D point)
        {
            return new Vector3D(point.X, point.Z, -point.Y);
        }

        private static Vector3D CrossVectors(Vector3D p1, Vector3D p2)
        {
            var ax = p1.X;
            var ay = p1.Y;
            var az = p1.Z;
            var bx = p2.X;
            var by = p2.Y;
            var bz = p2.Z;
            var x = ay * bz - az * by;
            var y = az * bx - ax * bz;
            var z = ax * by - ay * bx;
            return new Vector3D(x, y, z);
        }

        /// <summary>
        /// 根据三个点计算平面方程
        /// </summary>
        /// <param name="point1"></param>
        /// <param name="point2"></param>
        /// <param name="point3"></param>
        /// <returns></returns>
        public static PlaneEquation GetPlaneEquation(Vector3D point1, Vector3D point2, Vector3D point3)
        {
            try
            {
                if (IsParallel(point1, point2, point3))
                {
                    Logger.WriteLineError("MathTools3D GetPlaneEquation, three points is in one line.");
                    return new PlaneEquation { A = 0, B = 0, C = 0, D = 0 };
                }
                var x1 = point1.X;
                var y1 = point1.Y;
                var z1 = point1.Z;

                var x2 = point2.X;
                var y2 = point2.Y;
                var z2 = point2.Z;

                var x3 = point3.X;
                var y3 = point3.Y;
                var z3 = point3.Z;

                //平面方程Ax+By+CZ+D=0;
                var a = y1 * (z2 - z3) + y2 * (z3 - z1) + y3 * (z1 - z2);
                var b = z1 * (x2 - x3) + z2 * (x3 - x1) + z3 * (x1 - x2);
                var c = x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2);
                var d = -x1 * (y2 * z3 - y3 * z2) - x2 * (y3 * z1 - y1 * z3) - x3 * (y1 * z2 - y2 * z1);

                return new PlaneEquation { A = a, B = b, C = c, D = d };
            }
            catch (Exception e)
            {
                Logger.WriteLineError("MathTools3D GetPlaneEquation error," + e.Message + "," + e.StackTrace);
                return new PlaneEquation { A = 0, B = 0, C = 0, D = 0 };
            }
        }

        /// <summary>
        /// 计算点到平面的距离
        /// </summary>
        /// <param name="point"></param>
        /// <param name="plane"></param>
        /// <returns></returns>
        public static double GetPointToPlaneDistance(Vector3I point, PlaneEquation plane)
        {
            var temp1 = point.X * plane.A + point.Y * plane.B + point.Z * plane.C + plane.D;
            temp1 = Math.Abs(temp1);
            if (temp1 < MathToolsBasis.Precision)
            {
                return 0;
            }

            var temp2 = plane.A * plane.A + plane.B * plane.B + plane.C * plane.C;
            if (Math.Abs(temp2) < MathToolsBasis.Precision)
            {
                return 0;
            }

            temp2 = Math.Sqrt(temp2);
            return temp1 / temp2;
        }

        /// <summary>
        /// 根据三个点计算平面方程
        /// </summary>
        /// <param name="point1"></param>
        /// <param name="point2"></param>
        /// <param name="point3"></param>
        /// <returns></returns>
        public static PlaneEquation GetPlaneEquation(Vector3I point1, Vector3I point2, Vector3I point3)
        {
            try
            {
                if (IsParallel(point1, point2, point3))
                {
                    Logger.WriteLineError("MathTools3D GetPlaneEquation, three points is in one line.");
                    return new PlaneEquation { A = 0, B = 0, C = 0, D = 0 };
                }
                var x1 = point1.X;
                var y1 = point1.Y;
                var z1 = point1.Z;

                var x2 = point2.X;
                var y2 = point2.Y;
                var z2 = point2.Z;

                var x3 = point3.X;
                var y3 = point3.Y;
                var z3 = point3.Z;

                //平面方程Ax+By+CZ+D=0;
                var a = y1 * (z2 - z3) + y2 * (z3 - z1) + y3 * (z1 - z2);
                var b = z1 * (x2 - x3) + z2 * (x3 - x1) + z3 * (x1 - x2);
                var c = x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2);
                var d = -x1 * (y2 * z3 - y3 * z2) - x2 * (y3 * z1 - y1 * z3) - x3 * (y1 * z2 - y2 * z1);

                return new PlaneEquation { A = a, B = b, C = c, D = d };
            }
            catch (Exception e)
            {
                Logger.WriteLineError("MathTools3D GetPlaneEquation error," + e.Message + "," + e.StackTrace);
                return new PlaneEquation { A = 0, B = 0, C = 0, D = 0 };
            }
        }

        /// <summary>
        /// 判断三个点是否共线
        /// </summary>
        /// <param name="p1"></param>
        /// <param name="p2"></param>
        /// <param name="p3"></param>
        /// <returns></returns>
        public static bool IsParallel(Vector3I p1, Vector3I p2, Vector3I p3)
        {
            var v1 = new Vector3I(p2.X - p1.X, p2.Y - p1.Y, p2.Z - p1.Z);
            var v2 = new Vector3I(p2.X - p3.X, p2.Y - p3.Y, p2.Z - p3.Z);

            //判断是否平行(x,y,z)与（a,b,c）平行的条件。 xb - ya=0，xc - za = 0, yc - zb = 0
            var a1 = v1.X * v2.Y - v1.Y * v2.X;
            var a2 = v1.X * v2.Z - v1.Z * v2.X;
            var a3 = v1.Y * v2.Z - v1.Z * v2.Y;
            return Math.Abs(a1) < MathToolsBasis.Precision && Math.Abs(a2) < MathToolsBasis.Precision && Math.Abs(a3) < MathToolsBasis.Precision;
        }

        /// <summary>
        /// 判断三个点是否共线
        /// </summary>
        /// <param name="point1"></param>
        /// <param name="point2"></param>
        /// <param name="point3"></param>
        /// <returns></returns>
        public static bool IsParallel(Vector3D point1, Vector3D point2, Vector3D point3)
        {
            var p1 = new Vector3I((int)Math.Round(point1.X), (int)Math.Round(point1.Y), (int)Math.Round(point1.Z));
            var p2 = new Vector3I((int)Math.Round(point2.X), (int)Math.Round(point2.Y), (int)Math.Round(point2.Z));
            var p3 = new Vector3I((int)Math.Round(point3.X), (int)Math.Round(point3.Y), (int)Math.Round(point3.Z));
            return IsParallel(p1, p2, p3);
        }

        /// <summary>
        /// 2D坐标转3D坐标
        /// </summary>
        /// <param name="point2D"></param>
        /// <returns></returns>
        public static Vector3D Change2DTo3D(Point point2D, CoordinateTransformation3D coordinateTransformation3D)
        {
            var m1 = coordinateTransformation3D.RotationMatrix[0];
            var m2 = coordinateTransformation3D.RotationMatrix[1];
            var m4 = coordinateTransformation3D.RotationMatrix[3];
            var m5 = coordinateTransformation3D.RotationMatrix[4];
            var m7 = coordinateTransformation3D.RotationMatrix[6];
            var m8 = coordinateTransformation3D.RotationMatrix[7];

            var t1 = coordinateTransformation3D.TranslationMatrix[0];
            var t2 = coordinateTransformation3D.TranslationMatrix[1];
            var t3 = coordinateTransformation3D.TranslationMatrix[2];

            var x = m1 * point2D.X + m2 * point2D.Y + t1;
            var y = m4 * point2D.X + m5 * point2D.Y + t2;
            var z = m7 * point2D.X + m8 * point2D.Y + t3;

            return new Vector3D(x, y, z);
        }

        /// <summary>
        /// 三维空间，线段和平面的交点，endPoint1和endPoint2为线段的两个端点
        /// </summary>
        /// <param name="endPoint1"></param>
        /// <param name="endPoint2"></param>
        /// <param name="planeEquation"></param>
        /// <returns></returns>
        public static List<Vector3D> GetIntersectionOfLineAndPlane(Vector3I endPoint1, Vector3I endPoint2,
            PlaneEquation planeEquation)
        {
            var a = planeEquation.A;
            var b = planeEquation.B;
            var c = planeEquation.C;
            var d = planeEquation.D;
            var listEndPoint3D = new List<Vector3D>();
            //直线P1P2-----------------------------------------------------
            //判断直线是否在平面上
            var temp1 = a * endPoint1.X + b * endPoint1.Y + c * endPoint1.Z + d;
            var temp2 = a * endPoint2.X + b * endPoint2.Y + c * endPoint2.Z + d;
            if (Math.Abs(temp1) < MathToolsBasis.Precision && Math.Abs(temp2) < MathToolsBasis.Precision)
            {
                //直线在平面上，取端点，即p1和p2
                listEndPoint3D.Add(new Vector3D(endPoint1.X, endPoint1.Y, endPoint1.Z));
                listEndPoint3D.Add(new Vector3D(endPoint2.X, endPoint2.Y, endPoint2.Z));
            }

            if (Math.Abs(temp1) < MathToolsBasis.Precision && Math.Abs(temp2) >= MathToolsBasis.Precision)
            {
                //直线与平面相交，交点取P1
                listEndPoint3D.Add(new Vector3D(endPoint1.X, endPoint1.Y, endPoint1.Z));
            }

            if (Math.Abs(temp1) >= MathToolsBasis.Precision && Math.Abs(temp2) < MathToolsBasis.Precision)
            {
                //直线与平面相交，交点取P2
                listEndPoint3D.Add(new Vector3D(endPoint2.X, endPoint2.Y, endPoint2.Z));
            }

            if (Math.Abs(temp1) >= MathToolsBasis.Precision && Math.Abs(temp2) >= MathToolsBasis.Precision)
            {
                if (temp1 * temp2 < 0)
                {
                    //直线与平面相交，交点取P2
                    var x1 = endPoint1.X;
                    var y1 = endPoint1.Y;
                    var z1 = endPoint1.Z;
                    var x2 = endPoint2.X;
                    var y2 = endPoint2.Y;
                    var z2 = endPoint2.Z;

                    var temp = a * x1 - a * x2 + b * y1 - b * y2 + c * z1 - c * z2;
                    var x0 = -(d * x1 - d * x2 + b * x1 * y2 - b * x2 * y1 + c * x1 * z2 - c * x2 * z1) / temp;
                    var y0 = -(d * y1 - d * y2 - a * x1 * y2 + a * x2 * y1 + c * y1 * z2 - c * y2 * z1) / temp;
                    var z0 = -(d * z1 - d * z2 - a * x1 * z2 + a * x2 * z1 - b * y1 * z2 + b * y2 * z1) / temp;
                    listEndPoint3D.Add(new Vector3D(x0, y0, z0));
                }
            }
            return listEndPoint3D;
        }

        /// <summary>
        /// 去掉重复的点
        /// </summary>
        /// <param name="endPointListSrc"></param>
        /// <returns></returns>
        public static List<Vector3D> RemoveRepeatingPoint(List<Vector3D> endPointListSrc)
        {
            var endPointList = new List<Vector3D>();
            //去除掉重复的元素
            for (var i = 0; i < endPointListSrc.Count; ++i)
            {
                foreach (var endPoint1 in endPointListSrc)
                {
                    if (0 == endPointList.Count)
                    {
                        endPointList.Add(endPoint1);
                    }
                    else
                    {
                        var isRepeat = false;
                        foreach (var endPoint2 in endPointList)
                        {
                            if (IsEqualVector3D(endPoint1, endPoint2))
                            {
                                isRepeat = true;
                                break;
                            }
                        }

                        if (false == isRepeat)
                        {
                            //如果没有重复，则添加
                            endPointList.Add(endPoint1);
                        }
                    }
                }
            }
            return endPointList;
        }

        /// <summary>
        /// 获得模型所有的棱
        /// </summary>
        /// <param name="modelSize"></param>
        /// <returns></returns>
        public static List<LineSegment3I> GetModelAllEdge(ModelSize modelSize)
        {
            var modelEdges = new List<LineSegment3I>();
            //实际上就是求长方体8个定点组成的直线与平面的交点，如果其中某条直线在平面上，则取两个端点
            //所有的顶点为
            var vertexPoint1 = new Vector3I(0, 0, modelSize.ModelLengthZ - 1);
            var vertexPoint2 = new Vector3I(0, modelSize.ModelLengthY - 1, modelSize.ModelLengthZ - 1);
            var vertexPoint3 = new Vector3I(modelSize.ModelLengthX - 1, modelSize.ModelLengthY - 1,modelSize.ModelLengthZ - 1);
            var vertexPoint4 = new Vector3I(modelSize.ModelLengthX - 1, 0, modelSize.ModelLengthZ - 1);
            var vertexPoint5 = new Vector3I(0, 0, 0);
            var vertexPoint6 = new Vector3I(0, modelSize.ModelLengthY - 1, 0);
            var vertexPoint7 = new Vector3I(modelSize.ModelLengthX - 1, modelSize.ModelLengthY - 1, 0);
            var vertexPoint8 = new Vector3I(modelSize.ModelLengthX - 1, 0, 0);

            //1.p1p2
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint1, EndPointEnd = vertexPoint2 });
            //2.p2p3
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint2, EndPointEnd = vertexPoint3 });
            //3.p3p4
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint3, EndPointEnd = vertexPoint4 });
            //4.p1p4
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint1, EndPointEnd = vertexPoint4 });
            //5.p1p5
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint1, EndPointEnd = vertexPoint5 });
            //6.p2p6
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint2, EndPointEnd = vertexPoint6 });
            //7.p3p7
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint3, EndPointEnd = vertexPoint7 });
            //8.p4p8
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint4, EndPointEnd = vertexPoint8 });
            //9.p5p6
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint5, EndPointEnd = vertexPoint6 });
            //10.p6p7
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint6, EndPointEnd = vertexPoint7 });
            //11.p7p8
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint7, EndPointEnd = vertexPoint8 });
            //12.p5p8
            modelEdges.Add(new LineSegment3I { EndPointBegin = vertexPoint5, EndPointEnd = vertexPoint8 });

            return modelEdges;
        }

        /// <summary>
        ///  获得模型和平面的交点,X坐标值相等情况
        /// </summary>
        /// <param name="xValue"></param>
        /// <param name="modelSize"></param>
        /// <returns></returns>
        private static List<Vector3D> GetIntersectionOfPlaneAndModelX(int xValue, ModelSize modelSize)
        {
            var endPointList = new List<Vector3D>();
            var zeroPoint = new Vector3D(xValue, modelSize.ModelLengthY - 1, modelSize.ModelLengthZ - 1);
            var xAxisPoint = new Vector3D(xValue, 0, modelSize.ModelLengthZ - 1);

            //顺时针方向加入四个交点
            endPointList.Add(zeroPoint);
            endPointList.Add(xAxisPoint);
            endPointList.Add(new Vector3D(xValue, 0, 0));
            endPointList.Add(new Vector3D(xValue, modelSize.ModelLengthY - 1, 0));
            return endPointList;
        }

        /// <summary>
        ///  获得模型和平面的交点,Y坐标值相等情况
        /// </summary>
        /// <param name="yValue"></param>
        /// <param name="modelSize"></param>
        /// <returns></returns>
        private static List<Vector3D> GetIntersectionOfPlaneAndModelY(int yValue, ModelSize modelSize)
        {
            var endPointList = new List<Vector3D>();
            var zeroPoint = new Vector3D(modelSize.ModelLengthX - 1, yValue, modelSize.ModelLengthZ - 1);
            var xAxisPoint = new Vector3D(0, yValue, modelSize.ModelLengthZ - 1);

            //顺时针加入四个楞交点
            endPointList.Add(zeroPoint);
            endPointList.Add(xAxisPoint);
            endPointList.Add(new Vector3D(0, yValue, 0));
            endPointList.Add(new Vector3D(modelSize.ModelLengthX - 1, yValue, 0));
            return endPointList;
        }

        /// <summary>
        /// 获得模型和平面的交点,Z坐标值相等情况
        /// </summary>
        /// <param name="zValue"></param>
        /// <param name="modelSize"></param>
        /// <returns></returns>
        private static List<Vector3D> GetIntersectionOfPlaneAndModelZ(int zValue, ModelSize modelSize)
        {
            var endPointList = new List<Vector3D>();
            var zeroPoint = new Vector3D(modelSize.ModelLengthX - 1, modelSize.ModelLengthY - 1, zValue);
            var xAxisPoint = new Vector3D(0, modelSize.ModelLengthY - 1, zValue);

            //顺时针4个楞交点
            endPointList.Add(zeroPoint);
            endPointList.Add(xAxisPoint);
            endPointList.Add(new Vector3D(0, 0, zValue));
            endPointList.Add(new Vector3D(modelSize.ModelLengthX - 1, 0, zValue));
            return endPointList;
        }

        /// <summary>
        /// 获得模型和平面的交点,一般情况
        /// </summary>
        /// <param name="planeEquation"></param>
        /// <param name="modelSize"></param>
        /// <returns></returns>
        private static List<Vector3D> GetIntersectionOfPlaneAndModelNomal(PlaneEquation planeEquation, ModelSize modelSize)
        {
            //获得模型所有的棱
            var modelEdges = GetModelAllEdge(modelSize);
            var endPointList1 = new List<Vector3D>();
            foreach (var edge in modelEdges)
            {
                endPointList1.AddRange(GetIntersectionOfLineAndPlane(edge.EndPointBegin, edge.EndPointEnd,
                    planeEquation));
            }
            //去掉重复的端点
            var endPointList2 = RemoveRepeatingPoint(endPointList1);
            //确保端点在立方体上
            var endPointList = new List<Vector3D>();
            foreach (var endPoint in endPointList2)
            {
                if (IsInModel(endPoint, modelSize))
                {
                    endPointList.Add(endPoint);
                }
            }
            return endPointList;
        }

        /// <summary>
        /// 判断点是否在模型内
        /// </summary>
        /// <param name="point3D"></param>
        /// <param name="modelSize"></param>
        /// <returns></returns>
        public static bool IsInModel(Vector3D point3D, ModelSize modelSize)
        {
            var valueMin = MathToolsBasis.NegPrecision;
            var xMax = modelSize.ModelLengthX - 1 + MathToolsBasis.Precision;
            var yMax = modelSize.ModelLengthY - 1 + MathToolsBasis.Precision;
            var zMax = modelSize.ModelLengthZ - 1 + MathToolsBasis.Precision;
            return point3D.X > valueMin && point3D.Y > valueMin && point3D.Z > valueMin &&
                   point3D.X < xMax && point3D.Y < yMax && point3D.Z < zMax;
        }

        /// <summary>
        /// 获得模型和平面的交点
        /// </summary>
        /// <param name="one3DPlaneThreeBasicPoints"></param>
        /// <param name="modelSize"></param>
        /// <param name="sliceType"></param>
        /// <returns></returns>
        public static List<Vector3D> GetIntersectionOfPlaneAndModel(One3DPlaneThreeBasicPoints one3DPlaneThreeBasicPoints,
            ModelSize modelSize, ModelSliceType sliceType = ModelSliceType.Normal)
        {
            switch (sliceType)
            {
                case ModelSliceType.XEqual:
                    return GetIntersectionOfPlaneAndModelX(MathToolsBasis.DoubleToInt(one3DPlaneThreeBasicPoints.PointA.X), modelSize);
                case ModelSliceType.YEqual:
                    return GetIntersectionOfPlaneAndModelY(MathToolsBasis.DoubleToInt(one3DPlaneThreeBasicPoints.PointA.Y), modelSize);
                case ModelSliceType.ZEqual:
                    return GetIntersectionOfPlaneAndModelZ(MathToolsBasis.DoubleToInt(one3DPlaneThreeBasicPoints.PointA.Z), modelSize);
                case ModelSliceType.Normal:
                    //一般情况下获取切片
                    var planeEquation = GetPlaneEquation(one3DPlaneThreeBasicPoints.PointA, one3DPlaneThreeBasicPoints.PointB,
                        one3DPlaneThreeBasicPoints.PointC);
                    return GetIntersectionOfPlaneAndModelNomal(planeEquation, modelSize);
                default:
                    return new List<Vector3D>();
            }
        }

        /// <summary>
        /// 获得对应的图像端点坐标
        /// </summary>
        /// <param name="endPointList3D"></param>
        /// <returns></returns>
        private static List<Vector2I> GetRotatedImageEndPointsX(List<Vector3D> endPointList3D)
        {
            var endPointList2D = new List<Vector2I>();
            var width = MathToolsBasis.DoubleToInt(endPointList3D[0].Y);
            var height = MathToolsBasis.DoubleToInt(endPointList3D[0].Z);
            //四个端点， 顺时针方向加入2D点
            endPointList2D.Add(new Vector2I(0, 0));
            endPointList2D.Add(new Vector2I(width, 0));
            endPointList2D.Add(new Vector2I(width, height));
            endPointList2D.Add(new Vector2I(0, height));
            return endPointList2D;
        }

        /// <summary>
        /// 获得对应的图像端点坐标
        /// </summary>
        /// <param name="endPointList3D"></param>
        /// <returns></returns>
        private static List<Vector2I> GetRotatedImageEndPointsY(List<Vector3D> endPointList3D)
        {
            var endPointList2D = new List<Vector2I>();
            var width = MathToolsBasis.DoubleToInt(endPointList3D[0].X);
            var height = MathToolsBasis.DoubleToInt(endPointList3D[0].Z);
            //四个端点， 顺时针方向加入2D点
            endPointList2D.Add(new Vector2I(0, 0));
            endPointList2D.Add(new Vector2I(width, 0));
            endPointList2D.Add(new Vector2I(width, height));
            endPointList2D.Add(new Vector2I(0, height));
            return endPointList2D;
        }

        /// <summary>
        /// 获得对应的图像端点坐标
        /// </summary>
        /// <param name="endPointList3D"></param>
        /// <returns></returns>
        private static List<Vector2I> GetRotatedImageEndPointsZ(List<Vector3D> endPointList3D)
        {
            var endPointList2D = new List<Vector2I>();
            var width = MathToolsBasis.DoubleToInt(endPointList3D[0].X);
            var height = MathToolsBasis.DoubleToInt(endPointList3D[0].Y);
            //四个端点， 顺时针方向加入2D点
            endPointList2D.Add(new Vector2I(0, 0));
            endPointList2D.Add(new Vector2I(width, 0));
            endPointList2D.Add(new Vector2I(width, height));
            endPointList2D.Add(new Vector2I(0, height));
            return endPointList2D;
        }

        /// <summary>
        ///获得旋转后平面对应的零点三维坐标
        /// </summary>
        /// <param name="maxEndPoint"></param>
        /// <param name="nearPointX"></param>
        /// <param name="nearPointY"></param>
        /// <returns></returns>
        public static One2DPlaneThreeBasic3DPoints GetOne2DPlaneBasicPoints(List<Vector3D> endPointList3D)
        {
            try
            {
                //获得最大的端点----------------------------------
                var maxEndPoint = GetMaxPoint(endPointList3D);
                //获得与最大端点相邻的两个端点
                GetTwoMinDistancePoint(maxEndPoint, endPointList3D, out var nearPointX, out var nearPointY);

                //以maxEndPoint和nearPointX为二维图的x轴，方向maxEndPoint指向nearPointX
                //求向量maxEndPoint--nearPointX与向量maxEndPoint--nearPointY的夹角是否大于90，
                //如果大于90度则maxEndPoint点不能作为(0.0)点,因为此时以maxEndPoint为零点的话nearPointY的x坐标值为负数，
                //为了保证图像点都为正，需要以过nearPointY点，垂直于x轴的直线与x轴的的交点作为零点
                //cosA = u·v / | u || v |，如果cosA > 0 ，则小于90度，原点取maxEndPoint          
                var vector1 = GetVector(maxEndPoint, nearPointX);
                var vector2 = GetVector(maxEndPoint, nearPointY);
                var cosA = GetCosA3D(vector1, vector2);
                var zeroPoint = cosA < MathToolsBasis.NegPrecision ? GetZeroPoint(maxEndPoint, nearPointX, nearPointY) : maxEndPoint;

                return new One2DPlaneThreeBasic3DPoints
                {
                    ZeroPoint = zeroPoint,
                    XAxisPoint = nearPointX,
                    YAxisPoint = nearPointY
                };
            }
            catch (Exception e)
            {
                Logger.WriteLineError("MathTools3D GetOne2DPlaneBasicPoints  error," + e.Message + "," + e.StackTrace);
                return new One2DPlaneThreeBasic3DPoints
                {
                    ZeroPoint = new Vector3D(0, 0, 0),
                    XAxisPoint = new Vector3D(0, 0, 0),
                    YAxisPoint = new Vector3D(0, 0, 0)
                };
            }
        }

        /// <summary>
        /// 求平面的（0,0）点对应的三维坐标
        /// </summary>
        /// <param name="maxPoint"></param>
        /// <param name="nearPointX"></param>
        /// <param name="nearPointY"></param>
        /// <returns></returns>
        private static Vector3D GetZeroPoint(Vector3D maxPoint, Vector3D nearPointX, Vector3D nearPointY)
        {
            var x1 = nearPointX.X;
            var y1 = nearPointX.Y;
            var z1 = nearPointX.Z;
            var x2 = nearPointY.X;
            var y2 = nearPointY.Y;
            var z2 = nearPointY.Z;

            var xm = maxPoint.X;
            var ym = maxPoint.Y;
            var zm = maxPoint.Z;

            var denominator = (xm - x1) * (xm - x1) + (ym - y1) * (ym - y1) + (zm - z1) * (zm - z1);
            var e = x2 * xm - x1 * x2 + (y2 * ym - y1 * y2) + (z2 * zm - z1 * z2);
           
            var x0 = (e - x1 * (xm - x1) - (ym - y1) * y1 - z1 * (zm - z1)) * (xm - x1);
            x0 = x0 / denominator + x1;
            var y0 = (ym - y1) * e - x1 * (xm - x1) * (ym - y1) - (ym - y1) * (ym - y1) * y1 - z1 * (zm - z1) * (ym - y1);
            y0 = y0 / denominator + y1;
            var z0 = (e - x1 * (xm - x1) - (ym - y1) * y1 - z1 * (zm - z1)) * (zm - z1);
            z0 = z0 / denominator + z1;

            return new Vector3D(x0, y0, z0);
        }

        /// <summary>
        /// 计算三维世界点，旋转平移变换后的图像端点坐标
        /// </summary>
        /// <param name="endPointList3D"></param>
        /// <param name="sliceType"></param>
        /// <returns></returns>
        public static List<Vector2I> GetRotatedImageEndPoints(List<Vector3D> endPointList3D, One2DPlaneThreeBasic3DPoints plane2DBasic3DPoints,
                                                                                              ModelSliceType sliceType = ModelSliceType.Normal)
        {
            switch (sliceType)
            {
                case ModelSliceType.XEqual:
                    return GetRotatedImageEndPointsX(endPointList3D);
                case ModelSliceType.YEqual:
                    return GetRotatedImageEndPointsY(endPointList3D);
                case ModelSliceType.ZEqual:
                    return GetRotatedImageEndPointsZ(endPointList3D);
                case ModelSliceType.Normal:
                    return Chang3DTo2D(endPointList3D, plane2DBasic3DPoints);
                default:
                    return new List<Vector2I>();
            }
        }
        /// <summary>
        /// 计算两点间的距离
        /// </summary>
        /// <param name="pointA"></param>
        /// <param name="pointB"></param>
        /// <returns></returns>
        public static double GetTwoPointDistance(Vector3D pointA, Vector3D pointB)
        {
            var disX = pointA.X - pointB.X;
            var disY = pointA.Y - pointB.Y;
            var disZ = pointA.Z - pointB.Z;
            return Math.Sqrt(disX * disX + disY * disY + disZ * disZ);
        }

        /// <summary>
        /// 计算两点间的距离的平方
        /// </summary>
        /// <param name="pointA"></param>
        /// <param name="pointB"></param>
        /// <returns></returns>
        public static double GetTwoPointDistancePow2(Vector3D pointA, Vector3D pointB)
        {
            var disX = pointA.X - pointB.X;
            var disY = pointA.Y - pointB.Y;
            var disZ = pointA.Z - pointB.Z;
            return disX * disX + disY * disY + disZ * disZ;
        }

        /// <summary>
        /// 求距离maxEndPoint最近的点，如果存在多个点，则返回这些点中最大点
        /// </summary>
        /// <param name="maxEndPoint"></param>
        /// <param name="endPointList3D"></param>
        /// <returns></returns>
        public static Vector3D GetMinDistancePoint(Vector3D maxEndPoint, List<Vector3D> endPointList3D)
        {
            var nearPointX = new Vector3D();
            double dis = 0;
            var count = 0;

            foreach (var point in endPointList3D)
            {
                //判断是否是maxEndPoint点
                if (IsEqualVector3D(point, maxEndPoint))
                {
                    continue;
                }
                //求距离
                var disTemp = GetTwoPointDistance(maxEndPoint, point);
                if (0 == count)
                {
                    dis = disTemp;
                    nearPointX.X = point.X;
                    nearPointX.Y = point.Y;
                    nearPointX.Z = point.Z;
                }
                if (count > 0)
                {
                    if (MathToolsBasis.TwoDoubleEqual(disTemp, dis))
                    {
                        if (ComparePoint3D(point, nearPointX))
                        {
                            dis = disTemp;
                            nearPointX.X = point.X;
                            nearPointX.Y = point.Y;
                            nearPointX.Z = point.Z;
                        }
                    }
                }
                ++count;
            }
            return nearPointX;
        }

        /// <summary>
        /// 判断两个三维点是否相等
        /// </summary>
        /// <param name="point1"></param>
        /// <param name="point2"></param>
        /// <returns></returns>
        public static bool IsEqualVector3D(Vector3D point1, Vector3D point2)
        {
            return MathToolsBasis.TwoDoubleEqual(point1.X, point2.X) && MathToolsBasis.TwoDoubleEqual(point1.Y, point2.Y) && MathToolsBasis.TwoDoubleEqual(point1.Z, point2.Z);
        }

        /// <summary>
        /// 获得三维向量
        /// </summary>
        /// <param name="pointStart"></param>
        /// <param name="pointEnd"></param>
        /// <returns></returns>
        public static Vector3D GetVector(Vector3D pointStart, Vector3D pointEnd)
        {
            return new Vector3D(pointEnd.X - pointStart.X, pointEnd.Y - pointStart.Y, pointEnd.Z - pointStart.Z);
        }

        /// <summary>
        /// 求三维向量之间的夹角
        /// </summary>
        /// <param name="vector1"></param>
        /// <param name="vector2"></param>
        /// <returns></returns>
        public static double GetCosA3D(Vector3D vector1, Vector3D vector2)
        {
            if (IsEqualVector3D(vector1, new Vector3D(0, 0, 0)))
            {
                return 1;
            }
            if (IsEqualVector3D(vector2, new Vector3D(0, 0, 0)))
            {
                return 1;
            }

            var distanceX = GetTwoPointDistance(new Vector3D(0, 0, 0), vector1);
            var distanceY = GetTwoPointDistance(new Vector3D(0, 0, 0), vector2);
            if (Math.Abs(distanceX) < MathToolsBasis.Precision)
            {
                return 1;
            }
            if (Math.Abs(distanceY) < MathToolsBasis.Precision)
            {
                return 1;
            }
            //cosA = u·v / | u || v |，
            return (vector1.X * vector2.X + vector1.Y * vector2.Y + vector1.Z * vector2.Z) / (distanceX * distanceY);
        }

        /// <summary>
        /// 找最大点两个边的端点，大的点作为X轴坐标
        /// </summary>
        /// <param name="maxEndPoint"></param>
        /// <param name="endPointList3D"></param>
        /// <param name="nearPointX"></param>
        /// <param name="nearPoinitY"></param>
        private static void GetTwoMinDistancePoint(Vector3D maxEndPoint, List<Vector3D> endPointList3D, out Vector3D nearPointX, out Vector3D nearPoinitY)
        {
            nearPointX = new Vector3D();
            nearPoinitY = new Vector3D();

            nearPointX = GetMinDistancePoint(maxEndPoint, endPointList3D);
            var vector1 = GetVector(maxEndPoint, nearPointX);
            double minCosA = 2;
            //求与maxEndPoint--pD1的夹角最大的点
            foreach (var point in endPointList3D)
            {
                //判断是否是pD1点
                if (IsEqualVector3D(point, nearPointX) || IsEqualVector3D(point, maxEndPoint))
                {
                    continue;
                }
                var vector2 = GetVector(maxEndPoint, point);
                var cosA = GetCosA3D(vector1, vector2);
                if (cosA < minCosA)
                {
                    minCosA = cosA;
                    nearPoinitY.X = point.X;
                    nearPoinitY.Y = point.Y;
                    nearPoinitY.Z = point.Z;
                }
            }

            if (!ComparePoint3D(nearPointX, nearPoinitY))
            {
                var temp = new Vector3D { X = nearPoinitY.X, Y = nearPoinitY.Y, Z = nearPoinitY.Z };
                nearPoinitY.X = nearPointX.X;
                nearPoinitY.Y = nearPointX.Y;
                nearPoinitY.Z = nearPointX.Z;

                nearPointX.X = temp.X;
                nearPointX.Y = temp.Y;
                nearPointX.Z = temp.Z;
            }
        }

        /// <summary>
        /// 获得端点中最大的点
        /// </summary>
        /// <param name="endPointList3D"></param>
        /// <returns></returns>
        private static Vector3D GetMaxPoint(IEnumerable<Vector3D> endPointList3D)
        {
            var maxPoint = new Vector3D(0, 0, 0);
            foreach (var point in endPointList3D)
            {
                if (ComparePoint3D(point, maxPoint))
                {
                    maxPoint.X = point.X;
                    maxPoint.Y = point.Y;
                    maxPoint.Z = point.Z;
                }
            }
            return maxPoint;
        }

        /// <summary>
        /// 两个三维点大小比较,先按z排序，再按y排序，再按x排序
        /// </summary>
        /// <param name="point1"></param>
        /// <param name="point2"></param>
        /// <returns></returns>
        public static bool ComparePoint3D(Vector3D point1, Vector3D point2)
        {
            if (MathToolsBasis.TwoDoubleEqual(point1.Z, point2.Z))
            {
                if (MathToolsBasis.TwoDoubleEqual(point1.Y, point2.Y))
                {
                    if (MathToolsBasis.TwoDoubleEqual(point1.X, point2.X))
                    {
                        return false;
                    }
                    return point1.X > point2.X;
                }
                return point1.Y > point2.Y;
            }
            return point1.Z > point2.Z;
        }

        /// <summary>
        /// 获得模型切片的类型
        /// </summary>
        /// <param name="basicPoints"></param>
        /// <returns></returns>
        public static ModelSliceType GetModelSliceType(One3DPlaneThreeBasicPoints basicPoints)
        {
            //三个端点X坐标相等的情况
            if (MathToolsBasis.TwoDoubleEqual(basicPoints.PointA.X, basicPoints.PointB.X) &&
                MathToolsBasis.TwoDoubleEqual(basicPoints.PointA.X, basicPoints.PointC.X) &&
                MathToolsBasis.TwoDoubleEqual(basicPoints.PointB.X, basicPoints.PointC.X))
            {
                return ModelSliceType.XEqual;
            }

            //三个端点Y坐标相等的情况
            if (MathToolsBasis.TwoDoubleEqual(basicPoints.PointA.Y, basicPoints.PointB.Y) &&
                MathToolsBasis.TwoDoubleEqual(basicPoints.PointA.Y, basicPoints.PointC.Y) &&
                MathToolsBasis.TwoDoubleEqual(basicPoints.PointB.Y, basicPoints.PointC.Y))
            {
                return ModelSliceType.YEqual;
            }

            //三个端点Z坐标相等的情况
            if (MathToolsBasis.TwoDoubleEqual(basicPoints.PointA.Z, basicPoints.PointB.Z) &&
                MathToolsBasis.TwoDoubleEqual(basicPoints.PointA.Z, basicPoints.PointC.Z) &&
                MathToolsBasis.TwoDoubleEqual(basicPoints.PointB.Z, basicPoints.PointC.Z))
            {
                return ModelSliceType.ZEqual;
            }
            return ModelSliceType.Normal;
        }

        /// <summary>
        /// 计算切面的旋转矩阵
        /// </summary>
        /// <param name="basicPoints3D"></param>
        /// <param name="basicPoints2D"></param>
        /// <returns></returns>
        public static CoordinateTransformation3D GetCoordinateTransformationParameter(One2DPlaneThreeBasic3DPoints basicPoints3D,
                                                                          One2DPlaneThreeBasic2DPoints basicPoints2D)
        {
            var coordinateTransformation3D = new CoordinateTransformation3D
            {
                TranslationMatrix = new double[3],
                RotationMatrix = new double[9]
            };
            coordinateTransformation3D.TranslationMatrix[0] = basicPoints3D.ZeroPoint.X;
            coordinateTransformation3D.TranslationMatrix[1] = basicPoints3D.ZeroPoint.Y;
            coordinateTransformation3D.TranslationMatrix[2] = basicPoints3D.ZeroPoint.Z;

            //3D的ZeroPoint对应2D的ZeroPoint，3D的XAxisPoint对应2D的XAxisPoint，3D的YAxisPoint对应2D的YAxisPoint
            //XAxisPoint 2D
            var a1 = basicPoints2D.XAxisPoint.X;
            //YAxisPoint 2D
            var a2 = basicPoints2D.YAxisPoint.X;
            var b2 = basicPoints2D.YAxisPoint.Y;

            if (a1 == 0)
            {
                Logger.WriteLineError("MathTools3D GetCoordinateTransformationParameter error,The width of the plane after rotation is 0");
                return coordinateTransformation3D;
            }
            if (b2 == 0)
            {
                Logger.WriteLineError("MathTools3D GetCoordinateTransformationParameter error,The height of the plane after rotation is 0");
                return coordinateTransformation3D;
            }
            //3D的ZeroPoint
            var x0 = basicPoints3D.ZeroPoint.X;
            var y0 = basicPoints3D.ZeroPoint.Y;
            var z0 = basicPoints3D.ZeroPoint.Z;
            //XAxisPoint 3D
            var x1 = basicPoints3D.XAxisPoint.X;
            var y1 = basicPoints3D.XAxisPoint.Y;
            var z1 = basicPoints3D.XAxisPoint.Z;
            //YAxisPoint 3D
            var x2 = basicPoints3D.YAxisPoint.X;
            var y2 = basicPoints3D.YAxisPoint.Y;
            var z2 = basicPoints3D.YAxisPoint.Z;

            //RotationMatrix[1 2 3
            //4 5 6
            //7 8 9]
            //第一个和第二个分量
            coordinateTransformation3D.RotationMatrix[0] = (x1 - x0) / a1;
            coordinateTransformation3D.RotationMatrix[1] = (x2 - x0) / b2 + (a2 * x0 - a2 * x1) / (a1 * b2);
            //第4个和第5个分量
            coordinateTransformation3D.RotationMatrix[3] = (y1 - y0) / a1;
            coordinateTransformation3D.RotationMatrix[4] = (y2 - y0) / b2 + (a2 * y0 - a2 * y1) / (a1 * b2);
            //coordinateTransformation3D
            coordinateTransformation3D.RotationMatrix[6] = (z1 - z0) / a1;
            //m[7] = (a2 * z0 + a1 * z2 - a1 * z0 - a2 * z1) / (a1*b2);
            coordinateTransformation3D.RotationMatrix[7] = (z2 - z0) / b2 + (a2 * z0 - a2 * z1) / (a1 * b2);
            return coordinateTransformation3D;
        }

        /// <summary>
        /// 一个三维点转图像点
        /// </summary>
        /// <param name="point3D"></param>
        /// <param name="basicPoints"></param>
        /// <returns></returns>
        public static Vector2I Chang3DTo2D(Vector3D point3D, One2DPlaneThreeBasic3DPoints basicPoints)
        {
            var zeroPoint = basicPoints.ZeroPoint;
            var xAxisPoint = basicPoints.XAxisPoint;
            //旋转后，图像x轴上的点
            var disX = GetTwoPointDistance(zeroPoint, xAxisPoint);
            if (IsEqualVector3D(zeroPoint, point3D))
            {
                return new Vector2I(0, 0);
            }
            //求目标点到原点和nearPointX的距离
            var d1 = GetTwoPointDistancePow2(point3D, zeroPoint);
            var d2 = GetTwoPointDistancePow2(point3D, xAxisPoint);
            //src_point的横坐标是d1*cos(a),a是目标点与原点和m1点之间的夹角
            //由极坐标公式推出
            var a2 = (d1 - d2 + disX * disX) / 2 / disX;
            var b2 = Math.Sqrt(Math.Abs(d1 - a2 * a2));
            return new Vector2I(MathToolsBasis.DoubleToInt(a2), MathToolsBasis.DoubleToInt(b2));
        }

        /// <summary>
        /// 多个三维点转图像点
        /// </summary>
        /// <param name="endPointList3D"></param>
        /// <param name="basicPoints"></param>
        /// <returns></returns>
        public static List<Vector2I> Chang3DTo2D(List<Vector3D> endPointList3D, One2DPlaneThreeBasic3DPoints basicPoints)
        {
            var endPointList2I = new List<Vector2I>();
            var zeroPoint = basicPoints.ZeroPoint;
            var xAxisPoint = basicPoints.XAxisPoint;
            //旋转后，图像x轴上的点
            var disX = GetTwoPointDistance(zeroPoint, xAxisPoint);
            foreach (var point3D in endPointList3D)
            {
                if (IsEqualVector3D(zeroPoint, point3D))
                {
                    endPointList2I.Add(new Vector2I(0, 0));
                    continue;
                }
                //求目标点到原点和nearPointX的距离的平方
                var d1 = GetTwoPointDistancePow2(point3D, zeroPoint);
                var d2 = GetTwoPointDistancePow2(point3D, xAxisPoint);
                //src_point的横坐标是d1*cos(a),a是目标点与原点和m1点之间的夹角
                //由极坐标公式推出
                var a2 = (d1 - d2 + disX * disX) / 2 / disX;
                var b2 = Math.Sqrt(Math.Abs(d1 - a2 * a2));
                endPointList2I.Add(new Vector2I(MathToolsBasis.DoubleToInt(a2), MathToolsBasis.DoubleToInt(b2)));
            }
            return endPointList2I;
        }

        /// <summary>
        /// 按照顺时针排序端点
        /// </summary>
        /// <param name="endPointList3D"></param>
        /// <param name="endPointList2I"></param>
        /// <param name="zeroPoint"></param>
        public static void SortEndPointClockwise(One2DPlaneThreeBasic2DPoints basicPoints, List<Vector3D> endPointList3D, List<Vector2I> endPointList2I)
        {
            var num = endPointList3D.Count;
            if (num < 3)
            {
                return;
            }
            var vectorX = MathTools2D.GetVector(new Vector2I(0, 0), basicPoints.XAxisPoint);
            var endPointStruct = new List<EndPointStruct>();
            for (var i = 0; i < num; ++i)
            {

                var vector1 = MathTools2D.GetVector(new Vector2I(0, 0), endPointList2I[i]);
                var temp = new EndPointStruct
                {
                    EndPoint3D = endPointList3D[i],
                    EndPoint2I = endPointList2I[i],
                    CosA = MathTools2D.GetCosA2D(vectorX, vector1)
                };
                temp.Molecule = vectorX.X * vector1.X + vectorX.Y * vector1.Y;
                temp.Denominator = (int)(Math.Sqrt(vectorX.X * vectorX.X + vectorX.Y * vectorX.Y) *Math.Sqrt(vector1.X * vector1.X + vector1.Y * vector1.Y));               
                endPointStruct.Add(temp);
            }
            //从大到小排列
            endPointStruct.Sort(CompareEndPointStruct);
            endPointList3D.Clear();
            endPointList2I.Clear();
            foreach (var pointStruct in endPointStruct)
            {
                endPointList3D.Add(pointStruct.EndPoint3D);
                endPointList2I.Add(pointStruct.EndPoint2I);
            }
        }

        /// <summary>
        /// 结构体大小比较
        /// </summary>
        /// <param name="point1"></param>
        /// <param name="point2"></param>
        /// <returns></returns>
        public static int CompareEndPointStruct(EndPointStruct point1, EndPointStruct point2)
        {
            var smaller = 1;
            var bigger = -1;

            if (point1.EndPoint2I.X == 0 && point1.EndPoint2I.Y == 0)
            {
                return bigger;
            }

            if (point2.EndPoint2I.X == 0 && point2.EndPoint2I.Y == 0)
            {
                return smaller;
            }

            if (point1.EndPoint2I.Y == 0 && point2.EndPoint2I.Y == 0)
            {
                if (point1.EndPoint2I.X < point2.EndPoint2I.X)
                {               
                    return bigger;
                }

                if (point1.EndPoint2I.X > point2.EndPoint2I.X)
                {                
                    return smaller;
                }
            }

            if (point1.EndPoint2I.X == 0 && point2.EndPoint2I.X== 0)
            {
                if (point1.EndPoint2I.Y < point2.EndPoint2I.Y)
                {
                    return smaller;
                }

                if (point1.EndPoint2I.Y> point2.EndPoint2I.Y)
                {
                    return bigger;
                }
            }

            if (point1.EndPoint2I.Y == 0 && point2.EndPoint2I.Y != 0)
            {
                return bigger;
            }

            if (point1.EndPoint2I.Y != 0 && point2.EndPoint2I.Y == 0)
            {
                return smaller;
            }

            if (point1.EndPoint2I.X == 0 && point1.EndPoint2I.Y != 0 && point2.EndPoint2I.X !=0)
            {
                return smaller;
            }

            if (point2.EndPoint2I.X == 0 && point2.EndPoint2I.Y != 0 && point1.EndPoint2I.X != 0)
            {
                return bigger;
            }

            if (point1.CosA - point2.CosA <MathToolsBasis.NegPrecision)
            {
                return smaller;
            }
            if (point1.CosA - point2.CosA > MathToolsBasis.Precision)
            {
                return bigger;
            }

            if (point1.Molecule * point2.Denominator < point2.Molecule * point1.Denominator)
            {
                return smaller;
            }
            if (point1.Molecule * point2.Denominator >point2.Molecule * point1.Denominator)
            {
                return bigger;
            }

            if (point1.EndPoint2I.X < point2.EndPoint2I.X)
            {
                return bigger;
            }
            if (point1.EndPoint2I.X > point2.EndPoint2I.X)
            {
                return smaller;
            }

            if (point1.EndPoint2I.Y < point2.EndPoint2I.Y)
            {
                return smaller;
            }
            if (point1.EndPoint2I.Y > point2.EndPoint2I.Y)
            {
                return bigger;
            }           
            return 0;
        }

        /// <summary>
        /// 将模型切面的三个基础点坐标转成二维坐标
        /// </summary>
        /// <param name="basicPoints"></param>
        /// <returns></returns>
        public static One2DPlaneThreeBasic2DPoints ChangePlaneBasic3DPointTo2D(One2DPlaneThreeBasic3DPoints basicPoints)
        {
            var zeroPoint3D = basicPoints.ZeroPoint;
            //旋转后，图像x轴上的点
            var nearPointX3D = basicPoints.XAxisPoint;
            var nearPointY3D = basicPoints.YAxisPoint;
            var disX = GetTwoPointDistance(basicPoints.ZeroPoint, basicPoints.XAxisPoint);
            //求目标点到原点和nearPointX的距离
            var d1 = GetTwoPointDistancePow2(nearPointY3D, zeroPoint3D);
            var d2 = GetTwoPointDistancePow2(nearPointY3D, nearPointX3D);
            //src_point的横坐标是d1*cos(a),a是目标点与原点和m1点之间的夹角
            //由极坐标公式推出
            var a2 = (d1 - d2 + disX * disX) / 2 / disX;
            var b2 = Math.Sqrt(Math.Abs(d1 - a2 * a2));

            var zeroPoint2D = new Vector2I(0, 0);
            var nearPointX2D = new Vector2I(MathToolsBasis.DoubleToInt(disX), 0);
            var nearPointY2D = new Vector2I(MathToolsBasis.DoubleToInt(a2), MathToolsBasis.DoubleToInt(b2));

            return new One2DPlaneThreeBasic2DPoints
            {
                ZeroPoint = zeroPoint2D,
                XAxisPoint = nearPointX2D,
                YAxisPoint = nearPointY2D
            };
        }

    }
}