2.     public class Line : IComparable<Line>
    3.     {
    4.         #region Members
    6.         private PointF start;
    7.         private PointF end;
    9.         #endregion
    11.         #region Constructors
    13.         public Line(PointF start, PointF end)
    14.         {
    15.             this.start = start;
    16.             this.end = end;
    17.         }
    19.         #endregion
    21.         #region Properties
    23.         public PointF Start
    24.         {
    25.             get
    26.             {
    27.                 return start;
    28.             }
    29.             set
    30.             {
    31.                 start = value;
    32.             }
    33.         }
    35.         public PointF End
    36.         {
    37.             get
    38.             {
    39.                 return end;
    40.             }
    41.             set
    42.             {
    43.                 end = value;
    44.             }
    45.         }
    47.         public double Angle
    48.         {
    49.             get
    50.             {
    51.                 double dX = End.X - Start.X;
    52.                 double dY = End.Y - Start.Y;
    54.                 double angle = Math.Atan(dY / dX) * 180 / Math.PI;
    56.                 if (dX < 0)
    57.                 {
    58.                     angle += 180;
    59.                 }
    61.                 if (angle < 0)
    62.                 {
    63.                     angle += 360;
    64.                 }
    66.                 return angle;
    67.             }
    68.         }
    70.         #endregion
    72.         #region Functions
    74.         public double IncludedAngleWith(Line line)
    75.         {
    76.             double angle = line.Angle;
    77.             if (angle < this.Angle)
    78.             {
    79.                 angle += 360;
    80.             }
    82.             return angle - this.Angle;
    83.         }
    85.         public int CompareTo(Line line)
    86.         {
    87.             if (this.Angle < line.Angle)
    88.             {
    89.                 return -1;
    90.             }
    91.             else if (this.Angle == line.Angle)
    92.             {
    93.                 return 0;
    94.             }
    95.             else
    96.             {
    97.                 return 1;
    98.             }
    99.         }
    101.         #endregion
    102.     }
    104.         public bool Contains(PointF[] vertexArray, PointF point)
    105.         {
    106.             Line[] lineArray = new Line[vertexArray.Length];
    107.             for (int index = 0; index < vertexArray.Length; index++)
    108.             {
    109.                 if (vertexArray[index] == point)        //判断点与顶点重合
    110.                 {
    111.                     return false;
    112.                 }
    114.                 lineArray[index] = new Line(point, vertexArray[index]);
    115.             }
    117.             Array.Sort(lineArray);
    119.             for (int index = 0; index < lineArray.Length - 1; index++)
    120.             {
    121.                 if (lineArray[index].IncludedAngleWith(lineArray[index + 1]) >= 180)
    122.                 {
    123.                     return false;
    124.                 }
    125.             }
    127.             if (lineArray[lineArray.Length - 1].IncludedAngleWith(lineArray[0]) >= 180)
    128.             {
    129.                 return false;
    130.             }
    132.             return true;
    133.         }