[ARX程序]：构造自己的射线算法，测试点是否在曲线内的ARX完整代码 by XDSoft

YueFeng

1. 
   
2. // includes from ObjectARX Wizard
   
3. #include "acdb.h"          // acdb definitions
   
4. #include "adslib.h"          // ads defs
   
5. #include "aced.h"          // aced stuff
   
6. #include "dbsymtb.h"          // symboltables
   
7. #include "rxregsvc.h"          // unlock application
   
8. #include "dbcurve.h"
   
9. #include "gevec3d.h"
   
10. #include "dbray.h"
    
11. #include "dbautil.h"
    
12. #include "geassign.h"
    
13. #include "dbents.h"
    
14. 
    
15. // entry point for this application
    
16. extern "C" AcRx::AppRetCode acrxEntryPoint( AcRx::AppMsgCode msg, void* );
    
17. // message handlers
    
18. 
    
19. // helper functions
    
20. static void initApp  (void);
    
21. static void unloadApp(void);
    
22. 
    
23. void utilsisinside    (void );
    
24. 
    
25. 
    
26. // end of declaration
    
27. 
    
28. /////////////////////////////////////////////////////////////////////
    
29. // acrxEntryPoint(internal)
    
30. // This function is the entry point for your application.
    
31. /////////////////////////////////////////////////////////////////////
    
32. AcRx::AppRetCode acrxEntryPoint(AcRx::AppMsgCode msg, void* ptr)
    
33. {
    
34.   switch (msg) {
    
35.     case AcRx::kInitAppMsg:
    
36.       acrxUnlockApplication(ptr);
    
37.       initApp();
    
38.       break;
    
39.     case AcRx::kUnloadAppMsg:
    
40.       unloadApp();
    
41.       break;
    
42.     default:
    
43.       break;
    
44.   }
    
45.   return AcRx::kRetOK;
    
46. }
    
47. 
    
48. static void initApp(void)
    
49. {
    
50.   // register your autocad commands
    
51.   acedRegCmds->addCommand("UTILS", "ISINSIDE", "ISINSIDE", ACRX_CMD_MODAL,
    
52. utilsisinside);
    
53. 
    
54. } // END initApp()
    
55. 
    
56. static void unloadApp(void)
    
57. {
    
58.   // unregister your autocad commands
    
59.   acedRegCmds->removeGroup("UTILS");
    
60.   // END unloadApp()
    
61. }
    
62. 
    
63. 
    
64. enum IncidenceType {
    
65.     kIncidenceToLeft = 0,
    
66.     kIncidenceToRight = 1,
    
67.     kIncidenceToFront =2,
    
68.     kIncidenceUnknown };
    
69. 
    
70. IncidenceType CurveIncidence(AcDbCurve*pCurve, double param, AcGeVector3d
    
71. dir, AcGeVector3d normal )
    
72. {
    
73.     AcGeVector3d deriv1;
    
74. 
    
75.     pCurve->getFirstDeriv( param, deriv1 );
    
76.     if( deriv1.isParallelTo( dir )) {
    
77.      // need second degree analysis
    
78.      AcGeVector3d deriv2;
    
79.      pCurve->getSecondDeriv( param, deriv2 );
    
80.      if( deriv2.isZeroLength() ||  deriv2.isParallelTo( dir ) ) {
    
81.         return kIncidenceToFront;
    
82.      } else if(deriv2.crossProduct( dir ).dotProduct( normal ) < 0 ) {
    
83.         return kIncidenceToRight;
    
84.      } else {
    
85.         return kIncidenceToLeft;
    
86. 
    
87.      }
    
88.     }
    
89.      
    
90.     if( deriv1.crossProduct( dir ).dotProduct( normal ) < 0 ) {
    
91.      return kIncidenceToLeft;
    
92.     } else {
    
93.      return kIncidenceToRight;
    
94.     }
    
95. }
    
96. 
    
97. Adesk::Boolean IsInsideCurve(AcDbCurve*pCurve, AcGePoint3d testPt )
    
98. {
    
99.     if(!pCurve->isClosed() || !pCurve) {
    
100.      // cannot be inside
     
101.      return Adesk::kFalse;
     
102.     }
     
103. 
     
104.     Acad::ErrorStatus es;
     
105. 
     
106.     AcDb2dPolyline*p2dPoly = AcDb2dPolyline::cast(pCurve);
     
107.     if( p2dPoly != NULL && p2dPoly->polyType() != AcDb::k2dSimplePoly ) {
     
108.         // Not supported
     
109.         return Adesk::kFalse;
     
110.     }
     
111. 
     
112.     AcGePoint3d ptOnCurve;
     
113.     es = pCurve->getClosestPointTo(testPt, ptOnCurve  );
     
114.     if( testPt == ptOnCurve ) {
     
115.      return Adesk::kTrue;
     
116.     }
     
117. 
     
118.     // check its planar
     
119.     AcGePlane plane;
     
120.     AcDb::Planarity planarity;
     
121.     es = pCurve->getPlane(plane, planarity );
     
122.     if( es != Acad::eOk || planarity != AcDb::kPlanar ) {
     
123.      return Adesk::kFalse;
     
124.     }
     
125. 
     
126.     // make the test ray from the plane
     
127.     AcGeVector3d normal = plane.normal();
     
128.     AcGeVector3d testVector = normal.perpVector();
     
129.     AcDbRay ray;
     
130.     ray.setBasePoint(testPt);
     
131.     ray.setUnitDir(testVector);
     
132. 
     
133.     AcGePoint3dArray IntersectionPoints;
     
134. 
     
135.     // fire the ray at the curve
     
136.     es = pCurve->intersectWith(&ray, AcDb::kOnBothOperands,
     
137. IntersectionPoints);
     
138.     if(es != Acad::eOk) {
     
139.      return Adesk::kFalse;
     
140.     }
     
141.     int numberOfInters = IntersectionPoints.length();
     
142. 
     
143.     if(numberOfInters == 0) {
     
144.      // must be outside
     
145.      return Adesk::kFalse;
     
146.     }
     
147.     int nGlancingHits = 0;
     
148.     double epsilon = 2e-6; // ( trust me on this )
     
149.     for( int i=0;i < numberOfInters; i++ ) {
     
150. 
     
151.      // get the first point, and get its parameter
     
152.      AcGePoint3d hitPt = IntersectionPoints[i];
     
153.      double hitParam;
     
154.      es = pCurve->getParamAtPoint(hitPt, hitParam );
     
155.      if(es != Acad::eOk) {
     
156.         return Adesk::kFalse;
     
157.      }
     
158.      double inParam = hitParam - epsilon;
     
159.      double outParam = hitParam + epsilon;
     
160. 
     
161.      IncidenceType inIncidence = CurveIncidence(pCurve, inParam,
     
162. testVector, normal );
     
163.      IncidenceType outIncidence = CurveIncidence(pCurve, outParam,
     
164. testVector, normal );
     
165. 
     
166.      if( ( inIncidence == kIncidenceToRight && outIncidence ==
     
167. kIncidenceToLeft ) ||
     
168.         ( inIncidence == kIncidenceToLeft && outIncidence ==
     
169. kIncidenceToRight ) )
     
170.      {
     
171.         nGlancingHits ++;
     
172.      }
     
173.     }
     
174. 
     
175.     return (( numberOfInters + nGlancingHits) % 2 == 1);
     
176. }
     
177. 
     
178. void utilsisinside()
     
179. {
     
180.     ads_name eName;
     
181.     ads_point pt;
     
182. 
     
183.     if( RTNORM != ads_entsel( "\nPlease pick a curve ", eName, pt ) ) {
     
184.      return;
     
185.     }
     
186. 
     
187.     AcDbObjectId curveId;
     
188. 
     
189.     acdbGetObjectId( curveId, eName );
     
190. 
     
191.     AcDbCurve*pCurve = NULL;
     
192.     acdbOpenObject(pCurve, curveId, AcDb::kForRead );
     
193.     if( pCurve == NULL ) {
     
194.      return;
     
195.     }
     
196. 
     
197.     while( RTNORM == ads_getpoint( NULL, "\nPlease pick a point ", pt ) ) {
     
198. 
     
199.      acdbUcs2Wcs( pt, pt, Adesk::kFalse );
     
200.      
     
201.      Adesk::Boolean isIn;
     
202.      isIn = IsInsideCurve( pCurve, asPnt3d( pt ) );
     
203.      ads_printf("\n%s", isIn ? "INSIDE OR ON" : "OUTSIDE" );
     
204. 
     
205.    
     
206.     }
     
207. 
     
208.     pCurve->close();
     
209. }
     

复制代码