c#版点在面内算法

 

 

 

点在面算法,就是放射线算法,原理很简单,就是把一个点向任意方向发射（本程序是向下）,如果跟这个面有奇数个交点,证明点在面里面,若是偶数个,则是在外面(包括0)，算法主要是优化效率。本人水平有限，算法中肯定有不足之处，请大家海涵！

主要函数如下。

1.   struct TabPoint
2.    {
3.        private double x;
4.        public double X
5.        {
6.            get { return x; }
7.            set { x = value; }
8.        }
9.
10.        private double y;
11.        public double Y
12.        {
13.            get { return y; }
14.            set { y = value; }
15.        }
16.    }
17.
18.    struct Polygon
19.    {
20.        public ArrayList pointsArray;
21.        private double minx;
22.        public double MinX
23.        {
24.            get { return minx; }
25.            set { minx = value; }
26.        }
27.
28.        private double miny;
29.        public double MinY
30.        {
31.            get { return miny; }
32.            set { miny = value; }
33.        }
34.
35.        private double maxx;
36.        public double MaxX
37.        {
38.            get { return maxx; }
39.            set { maxx = value; }
40.        }
41.
42.        private double maxy;
43.        public double MaxY
44.        {
45.            get { return maxy; }
46.            set { maxy = value; }
47.        }
48.    }
49.
50.    class Analyse
51.    {
52.        private readonly double dis = 0.0000000001; 
53.
54.        //返回值：true点在面内  false点在面外 
55.        public bool JudgeMeetPoint(TabPoint tpt, ArrayList polygonPtArray)
56.        {
57.
58.            int MeetPointNum = 0;
59.
60.            int PolygonPtSize = polygonPtArray.Count;
61.            for (int k = 1; k < PolygonPtSize; k++)
62.            {
63.                TabPoint pt1 = (TabPoint)polygonPtArray[k - 1];
64.                TabPoint pt2 = (TabPoint)polygonPtArray[k];
65.
66.                if (((tpt.X <= pt1.X && tpt.X >= pt2.X) ||
67.                    (tpt.X >= pt1.X && tpt.X <= pt2.X)) &
68.                     (tpt.Y >= pt1.Y || tpt.Y >= pt2.Y) &
69.                     (pt1.X != pt2.X && pt1.Y != pt2.Y))
70.                {
71.                    //判断点是否在线上 
72.                    if (JudgePtInLine(pt1, pt2, tpt))
73.                    {
74.                        return true;
75.                    }
76.
77.                    //处理特殊情况，交点是端点的情况 
78.                    double temp;
79.                    //temp相当于被除数(斜率的分母)
80.                    temp = pt1.X - pt2.X;
81.                    if (temp >= -dis && temp <= dis)
82.                    {
83.                        //处理交点情况 
84.                        double dx = tpt.X - pt1.X;
85.                        if (dx >= -dis && dx <= dis)
86.                        {
87.                            int[] indexs = new int[2];
88.                            indexs[0] = 0;
89.                            indexs[1] = 0;
90.                            GetNotSame(polygonPtArray, k, ref indexs);
91.                            TabPoint linePt1, linePt2;
92.                            linePt1 = (TabPoint)polygonPtArray[indexs[0]];
93.                            linePt2 = (TabPoint)polygonPtArray[indexs[1]];
94.                            if (k > indexs[0])
95.                            {
96.                                break;
97.                            }
98.                            else
99.                            {
100.                                k = indexs[0] + 1;
101.                            }
102.                            if (tpt.Y > pt1.Y && ((tpt.X >= linePt1.X && tpt.X <= linePt2.X) ||
103.                                (tpt.X >= linePt2.X && tpt.X <= linePt1.X)))
104.                                MeetPointNum++;
105.                        }
106.                    }
107.                    else
108.                    {
109.                        double kk, bb;
110.                        double MeetPtY, MeetPtX;
111.                        kk = (pt1.Y - pt2.Y) / (pt1.X - pt2.X);
112.                        bb = pt1.Y - kk * pt1.X;
113.                        MeetPtY = kk * tpt.X + bb;
114.                        MeetPtX = tpt.X;
115.                        //处理特殊情况，交点是端点的情况 
116.                        double dx, dy, dx2, dy2;
117.                        dx = MeetPtX - pt1.X;
118.                        dy = MeetPtY - pt1.Y;
119.                        dx2 = MeetPtX - pt2.X;
120.                        dy2 = MeetPtY - pt2.Y;
121.                        if ((dx >= -dis && dx <= dis && dy >= -dis
122.                            && dy <= dis))
123.                        {
124.                            TabPoint pt3;
125.                            if (k == 1)
126.                            {
127.                                pt3 = (TabPoint)polygonPtArray[PolygonPtSize - 2];
128.                            }
129.                            else
130.                            {
131.                                pt3 = (TabPoint)polygonPtArray[k - 2];
132.                            }
133.                            //提取交点的上下两点分别在垂线的两侧 
134.                            if (tpt.Y > MeetPtY && ((MeetPtX >= pt3.Y && MeetPtX <= pt2.X) ||
135.                                (MeetPtX >= pt2.X && MeetPtX <= pt3.X)))
136.                                MeetPointNum++;
137.                        }
138.                        else if (!(dx2 >= -dis && dx2 <= dis && dy2 >= -dis
139.                                    && dy2 <= dis))
140.                        {
141.                            if (tpt.Y > MeetPtY)
142.                                MeetPointNum++;
143.                        }
144.                    }
145.                }
146.            }
147.
148.            if (MeetPointNum % 2 == 1)
149.                return true;
150.            else
151.                return false;
152.        }
153.        //判断点是否在线上 
154.        private bool JudgePtInLine(TabPoint tpt1, TabPoint tpt2, TabPoint tpt)
155.        {
156.            double dx1 = GetDistance(tpt1, tpt2);
157.            double dx2 = GetDistance(tpt, tpt1);
158.            double dx3 = GetDistance(tpt, tpt2);
159.            double dx = dx3 + dx2 - dx1;
160.
161.            if (dx >= -0.0000000001 && dx <= 0.0000000001)
162.            {
163.                return true;
164.            }
165.            return false;
166.        }
167.        //求取两点之间的距离 
168.        private double GetDistance(TabPoint tpt1, TabPoint tpt2)
169.        {
170.            double x = tpt1.X - tpt2.X;
171.            if (x <= 0)
172.            {
173.                x = -x;
174.            }
175.            double y = tpt1.Y - tpt2.Y;
176.            if (y <= 0)
177.            {
178.                y = -y;
179.            }
180.
181.            return System.Math.Sqrt(x * x + y * y);
182.        }
183.        //在链表中获取x轴不相同的点 
184.        private void GetNotSame(ArrayList pointArray, int index, ref int[] indexs)
185.        {
186.            indexs[0] = indexs[1] = -1;
187.            int size = pointArray.Count;
188.            TabPoint buftpt, tpt;
189.            tpt = (TabPoint)pointArray[index];
190.
191.            for (int i = index; i < size; i++)
192.            {
193.                buftpt = (TabPoint)pointArray[i];
194.                if (buftpt.X != tpt.X)
195.                {
196.                    indexs[0] = i;
197.                    break;
198.                }
199.            }
200.
201.            if (indexs[0] == -1)
202.            {
203.                for (int i = 0; i < size; i++)
204.                {
205.                    buftpt = (TabPoint)pointArray[i];
206.                    if (buftpt.X != tpt.X)
207.                    {
208.                        indexs[0] = i;
209.                        break;
210.                    }
211.                }
212.            }
213.
214.
215.            for (int j = index; j >= 0; j--)
216.            {
217.                buftpt = (TabPoint)pointArray[j];
218.                if (buftpt.X != tpt.X)
219.                {
220.                    indexs[1] = j;
221.                    break;
222.                }
223.            }
224.            if (indexs[1] == -1)
225.            {
226.                for (int j = size - 1; j >= 0; j--)
227.                {
228.                    buftpt = (TabPoint)pointArray[j];
229.                    if (buftpt.X != tpt.X)
230.                    {
231.                        indexs[1] = j;
232.                        break;
233.                    }
234.                }
235.            }
236.        }
237.
238.        public bool JudgeInRect(TabPoint minPt,TabPoint maxPt,TabPoint pt)
239.        {
240.            if (pt.X >= minPt.X && pt.X <= maxPt.X && pt.Y >= minPt.Y && pt.Y <= maxPt.Y)
241.            {
242.                return true;
243.            }
244.            else
245.            {
246.                return false;
247.            }
248.        }