IsPointInBoundary在边界内

admin

1.                                     //-------------------------------------//
   
2.                                     //  IsPointInBoundary                  //
   
3.                                     //-------------------------------------//
   
4. int IsPointInBoundary( ads_point pPt, ads_point *pOutline, int nNum, int fAllowOnPerimeter )
   
5. {
   
6.     int nNumLft;        // Number of Boundary Intersections to the Left of this Point
   
7.     int nNumRgt;        // Number of Boundary Intersections to the Right of this Point
   
8.     int nKnt;
   
9.     int nPrev;
   
10.     int nNext;
    
11.     ads_point pPt1;     // Used with acdbInters()
    
12.     ads_point pInt;     // Intersection Point returned by acdbInters()
    
13. 
    
14.     double dTol = 0.1 * pSettings.dMetricScl;
    
15. 
    
16.         // Create pPt1 to Be Horzontal from pPt
    
17.     Cpoint( pPt1, pPt );
    
18.     pPt1[X] += 120.0;
    
19. 
    
20.         // For Each Line of the Outline, Intersect a Horizontal line through pPt
    
21.     nNumLft = 0;
    
22.     nNumRgt = 0;
    
23.     for( nKnt=1; nKnt<nNum; nKnt++ ) {
    
24.             // Make sure there's potential for a horizontal intersection
    
25.         if ( pOutline[nKnt-1][Y] + dTol < pPt[Y] && pOutline[nKnt][Y] + dTol < pPt[Y] ) {
    
26.             continue;
    
27.         }
    
28.         if ( pOutline[nKnt-1][Y] - dTol > pPt[Y] && pOutline[nKnt][Y] - dTol > pPt[Y] ) {
    
29.             continue;
    
30.         }
    
31. 
    
32.             // Check for Horizontal Segment
    
33.         if ( fabs( pOutline[nKnt][Y] - pPt[Y] ) < 0.1 && fabs( pOutline[nKnt-1][Y] - pPt[Y] ) < 0.1 ) {
    
34.                 // If the Point is On this Segment, then use the fAllowOnPerimeter Variable
    
35.             if ( IsPointOnLine( pPt, pOutline[nKnt-1], pOutline[nKnt], 0.05 )) {
    
36.                 if ( fAllowOnPerimeter ) {
    
37.                     return( TRUE );
    
38.                 } else {
    
39.                     return( FALSE );
    
40.                 }
    
41.             }
    
42. 
    
43.                 // Horizontal, if the Points Before and After this Segment are both Below or both Above,
    
44.                 // Skip this segment
    
45.             if ( nKnt-2 < 0 ) {
    
46.                 if ( AboutEqualPts( pOutline[nNum-1], pOutline[0] )) {
    
47.                     nPrev = nNum - 2;
    
48.                 } else {
    
49.                     nPrev = nNum - 1;
    
50.                 }
    
51.             } else {
    
52.                 nPrev = nKnt - 2;
    
53.             }
    
54.             if ( nKnt < nNum-1 ) {
    
55.                 nNext = nKnt + 1;
    
56.             } else {
    
57.                 nNext = 1;
    
58.             }
    
59.             if ( pOutline[nPrev][Y] + dTol < pPt[Y] && pOutline[nNext][Y] + dTol < pPt[Y] ) {
    
60.                 continue;
    
61.             } else if ( pOutline[nPrev][Y] + dTol > pPt[Y] && pOutline[nNext][Y] + dTol > pPt[Y] ) {
    
62.                 continue;
    
63.             }
    
64.         }
    
65. 
    
66.             // Check for Segment totally to the Left
    
67.         if ( pOutline[nKnt-1][X] + dTol < pPt[X] && pOutline[nKnt][X] + dTol < pPt[X] ) {
    
68.             if ( fabs( pOutline[nKnt][Y] - pPt[Y] ) < 0.1 ) {
    
69.                 if ( fabs( pOutline[nKnt-1][Y] - pPt[Y] ) > 0.1 ) {
    
70.                         // Skip this if it's a Horizontal Segment
    
71.                     Cpoint( pInt, pOutline[nKnt] );
    
72.                     goto ProcessEndPoint;
    
73.                 }
    
74.             }
    
75.             nNumLft++;
    
76.             continue;
    
77.         }
    
78. 
    
79.             // Check for Segment totally to the right
    
80.         if ( pOutline[nKnt-1][X] - dTol > pPt[X] && pOutline[nKnt][X] - dTol > pPt[X] ) {
    
81.             if ( fabs( pOutline[nKnt][Y] - pPt[Y] ) < 0.1 ) {
    
82.                 if ( fabs( pOutline[nKnt-1][Y] - pPt[Y] ) > 0.1 ) {
    
83.                         // Skip this if it's a Horizontal Segment
    
84.                     Cpoint( pInt, pOutline[nKnt] );
    
85.                     goto ProcessEndPoint;
    
86.                 }
    
87.             }
    
88.             nNumRgt++;
    
89.             continue;
    
90.         }
    
91. 
    
92.             // If the Point is On this Segment, then use the fAllowOnPerimeter Variable
    
93.         if ( IsPointOnLine( pPt, pOutline[nKnt-1], pOutline[nKnt], 0.05 )) {
    
94.             if ( fAllowOnPerimeter ) {
    
95.                 return( TRUE );
    
96.             } else {
    
97.                 return( FALSE );
    
98.             }
    
99.         }
    
100. 
     
101.             // Intersect with the Segment
     
102.         if ( acdbInters( pPt, pPt1, pOutline[nKnt-1], pOutline[nKnt], FALSE, pInt ) != RTNORM ) {
     
103.             continue;
     
104.         }
     
105.             // If it's one of the Vertex Points, process it Differently
     
106.         if ( AboutEqualPts( pInt, pOutline[nKnt] )) {
     
107. ProcessEndPoint:
     
108.             if ( pOutline[nKnt-1][Y] + dTol < pPt[Y] ) {
     
109.                 if ( nKnt < nNum-1 ) {
     
110.                     if ( pOutline[nKnt+1][Y] + dTol < pPt[Y] || fabs( pOutline[nKnt+1][Y] - pPt[Y] ) < 0.1 ) {
     
111.                         goto ProcessInt;
     
112.                     }
     
113.                 } else {
     
114.                     if ( pOutline[1][Y] + dTol < pPt[Y] || fabs( pOutline[1][Y] - pPt[Y] ) < 0.1 ) {
     
115.                         goto ProcessInt;
     
116.                     }
     
117.                 }
     
118.             } else {
     
119.                 if ( nKnt < nNum-1 ) {
     
120.                     if ( pOutline[nKnt+1][Y] - dTol > pPt[Y] || fabs( pOutline[nKnt+1][Y] - pPt[Y] ) < 0.1 ) {
     
121.                         goto ProcessInt;
     
122.                     }
     
123.                 } else {
     
124.                     if ( pOutline[1][Y] - dTol > pPt[Y] || fabs( pOutline[1][Y] - pPt[Y] ) < 0.1 ) {
     
125.                         goto ProcessInt;
     
126.                     }
     
127.                 }
     
128.             }
     
129.         } else {
     
130. ProcessInt:
     
131.                 // See if it's to the Left or Right
     
132.             if ( pInt[X] < pPt[X] ) {
     
133.                 nNumLft++;
     
134.             } else {
     
135.                 nNumRgt++;
     
136.             }
     
137.         }
     
138.     }
     
139. 
     
140. //acutPrintf( _T("pPt=(%f,%f), nNumLft=%d, nNumRgt=%d\n"), pPt[X], pPt[Y], nNumLft, nNumRgt );
     
141.         // To be Inside the Boundary, both nNumLft and nNumRgt MUST be ODD
     
142.     if (( nNumLft % 2 ) == 0 ) {
     
143.         return( FALSE );
     
144.     }
     
145.     if (( nNumRgt % 2 ) == 0 ) {
     
146.         return( FALSE );
     
147.     }
     
148. 
     
149.     return( TRUE );
     
150. }
     
151. 
     

复制代码