NX二次开发源码： 获取面的相邻面的信息

admin

通过这个代码，可以获取选择面的相邻面的信息
NX open C++中使用了 选择对象 selectobject 函数，通过面获取边数据，通过边获取面，从而得到信息！
/ m# v2 ]+ v. K% A9 j3 A
1 `' f3 p; j* J% |( K. W8 T

1. #include <uf.h>
   
2. #include <uf_ui.h>
   
3. #include <uf_object_types.h>
   , b* q1 r# c$ V$ z( U% R
4. 
     A: }0 X. S7 D# b9 N9 P* w" V
5. #include <NXOpen/Edge.hxx>
   5 \& {$ `; e/ A  s
6. #include <NXOpen/Face.hxx>
   9 K/ W$ V/ \  [% }
7. 
   
8. #include <NXOpen/ListingWindow.hxx>
   0 _; ~& u/ n# t% _/ x, @
9. #include <NXOpen/NXException.hxx>
   % K# G5 M, D4 p% H6 U
10. #include <NXOpen/NXMessageBox.hxx>
    % s5 U5 C2 ?& A, U) C
11. #include <NXOpen/NXObject.hxx>
    ) v$ K( ]  Y9 P/ K, p
12. #include <NXOpen/Part.hxx>
    
13. #include <NXOpen/ParTCollection.hxx>
    - C4 m7 E0 `+ N5 @
14. #include <NXOpen/SelectDisplayableObject.hxx>
    
15. #include <NXOpen/SelectDisplayableObjectList.hxx>
    4 N! ]9 S/ C9 q2 Q) S# X# R
16. #include <NXOpen/SelectObject.hxx>
    3 N2 e" G3 o7 I" v
17. #include <NXOpen/SelectObjectList.hxx>
    
18. #include <NXOpen/Selection.hxx>
    
19. #include <NXOpen/Session.hxx>
    8 v% O5 M+ F4 a
20. #include <NXOpen/UI.hxx>
    " C4 _( R: J. x  @$ \4 a
21. #include <NXOpen/View.hxx>
    
22. 
    
23. #include <iostream>
    . D5 _! t' n3 J' b9 k
24. #include <sstream>
    
25. #include <list>
    ! B& k, e: \# ^' w" {8 l
26. 
    
27. using namespace NXOpen;
    
28. using namespace NXOpen::Annotations;
    
29. using namespace std;
    , {# `8 ]0 W, y( o% ^& D& R
30. 
    
31. class Gtac
    ' r+ e1 F# r5 S1 Q. K$ \* w4 S4 X
32. {
    / S  v  w' ~- x% V4 Q- `
33.     // class members
    
34. public:
    
35.     static Session *theSession;
    
36.     static UI *theUI;
    7 q: [/ Y1 x# r9 K( P0 q3 X
37. 
    
38.     Gtac();
    . t& f$ M' u% S7 [
39.     ~Gtac();
    
40. 
    
41.     void do_it();
    
42. 
    
43. private:
    9 O0 I0 Y: K& g) \3 @) v: r. ]6 U
44.     Part *workPart, *displayPart;
    & Q, g( P$ c. h3 U: c/ B8 j
45.     Selection *sm;
    ' T. e5 L/ @0 Y- x  y- f# N# D6 O
46.     NXMessageBox *mb;
    8 c& o; N8 w( x8 u. F' k4 P
47.     ListingWindow *lw;
    
48. 
    
49.     Face* select_a_face();
    
50. 
    + o% e2 Z4 j. l  @( t+ \
51. };
    % {3 w! w5 C$ L+ k% y% ?; H. p
52. 
    / H* X* d5 M. S) c) t& V4 b
53. //------------------------------------------------------------------------------
    1 l5 _7 o! h) M8 y" H0 e/ T
54. // Initialize static variables
    
55. //------------------------------------------------------------------------------
    9 s7 e8 J) ^! z
56. Session *(Gtac::theSession) = NULL;
    
57. UI *(Gtac::theUI) = NULL;
    
58. 
    + t' Z. x  P9 f+ b! f- q$ m
59. //------------------------------------------------------------------------------
    9 T& B! q# p& ?  }3 a9 A5 Z
60. // Declaration of global variables
    7 L3 c" v/ }, X$ H$ @9 v2 f4 Z
61. //------------------------------------------------------------------------------
    ( ]) g8 }5 R& T# ^, T! T# r
62. Gtac *theGtac;
    # E# X& K* u) y2 }: C/ o7 V, u
63. 
    
64. //------------------------------------------------------------------------------
    
65. // Constructor
    # a4 J: k) D' a8 |
66. //------------------------------------------------------------------------------
    1 l/ A/ B) G9 g8 C/ N! \: ?
67. Gtac::Gtac()
    5 M9 ]9 o  b' t6 b7 w, q
68. {
    8 b9 U" s7 Z5 L& j8 A( r
69.     // Initialize the NX Open C++ API environment
    
70.     Gtac::theSession = NXOpen::Session::GetSession();
    4 @# `( N9 @( s1 B& _
71.     Gtac::theUI = UI::GetUI();
    * N0 z( r! J9 r5 }1 j' j
72. 
      d9 E7 Z* X9 Q' U
73.     sm = theUI->SelectionManager();
    0 L+ }1 j& k! E9 I
74.     mb = theUI->NXMessageBox();
    
75.     lw = theSession->ListingWindow();
    
76. 
    
77.     workPart = 0;
    7 w; B" U1 ]7 s3 x
78.     displayPart = 0;
    . t3 l  M9 y, z. ^5 _
79. }
    0 T3 O& c/ Y( |* ]" F# v+ T/ C% y
80. 
    . z# D0 B! H! S6 u
81. //------------------------------------------------------------------------------
    
82. // Destructor
    
83. //------------------------------------------------------------------------------
    
84. Gtac::~Gtac()
    
85. {
    6 j5 j: U/ U' K- k6 s9 A0 c
86. }
    
87. 
    
88. //------------------------------------------------------------------------------
    , F) q; [: v; x7 Y' e8 t
89. // Selection
    0 u- @+ i3 U  T4 P: o; Z) E
90. //------------------------------------------------------------------------------
    ! Q9 X- m" u  b' ^( y
91. Face* Gtac::select_a_face()
    + v: Y* _' T) f# M5 V3 @
92. {
    0 f# M. w7 C; \/ c3 ~7 w: S
93.     // ask user to select a face
    3 P' [- f6 O" G7 P- w6 [
94.     UI *ui = UI::GetUI();
    
95.     Selection *sm = ui->SelectionManager();
    
96.     NXMessageBox *mb = ui->NXMessageBox(); // as of NX5
    ! ]' O4 H0 f. S6 h) o/ x
97. 
    
98.     NXString message("Select Face:");
    . m, z: x' L( \& M1 X
99.     NXString title("Select Face");
    
100.     Selection::SelectionScope scope = Selection::SelectionScopeUseDefault;
     
101.     Selection::SelectionAction action = Selection::SelectionActionClearAndEnableSpecific;
     & J; L1 c* V) t9 ^- I  z6 r% c
102.     bool include_features = 0;
     
103.     bool keep_highlighted = 0;
     
104. 
     
105.     // Define the mask triple(s)
     3 F0 R% n7 ~: j; x, r( ?) _
106.     std::vector<Selection::MaskTriple> mask(1);
     " P& a  Q( R  ?  B" B
107.     mask[0] = Selection::MaskTriple( UF_solid_type, 0, UF_UI_SEL_FEATURE_ANY_FACE  );
     
108.     Point3d cursor;
     $ r6 D. r" Y7 Z" a& v
109.     NXObject *object;
     - [0 f9 f, Q4 P6 K" L( B" ?& _
110. 
     7 v9 ]6 A1 `# s! ~, A  k
111.     // Select objects using filter defined by mask triples
     ; s# r$ J  _  N: g7 f
112.     Selection::Response res = sm->SelectObject(
     
113.         message, title, scope, action, include_features,
     ' q. f3 b& @" D
114.             keep_highlighted, mask, &object, &cursor );
     
115. 
     
116.     if( res == Selection::ResponseObjectSelected )
     
117.     {
     . G0 q# P9 n: O# B
118.         Face *aFace;
     7 R9 Y# Z# j7 O1 w# c
119.         aFace = (Face *)(object);
     , t4 p0 ^7 c# s2 \; K& ^
120.         return aFace;
     
121.     }
     
122. 
     5 E6 C0 X9 S- U+ O) \9 z+ E
123.     return 0;
     
124. }
     
125. 
     
126. //------------------------------------------------------------------------------
     5 @! f( g& A. v( q
127. // start with our job...
     
128. //------------------------------------------------------------------------------
     $ z1 [, m7 m% X. a" l6 m4 q6 `9 h
129. void Gtac::do_it()
     $ p6 ~! A2 m: U' N
130. {
     $ k' T& A+ N) Y% z; {+ u
131.     workPart = theSession->Parts()->Work();
     
132.     Part *displayPart = theSession->Parts()->Display();
     " I3 ^1 p& G6 q; U( n
133.     stringstream out;
     
134. 
     
135.     Face *theFace = 0;
     
136.     std::list<Face*> myfaces;
       y' y0 ^5 C( J# T5 u2 N7 h
137.    
     / p! e8 N! H) n* U
138.     while( (theFace=select_a_face()) != 0 )
     
139.     {
     9 {  i; B; D, L4 w, M3 J' D
140.         if(! lw->IsOpen() ) lw->Open();
     $ I" ?3 m7 g3 \& i0 ~* o9 w4 S
141. 
     . W5 x. j! D* p, o7 M4 |0 w
142.         out << "Selected Object: " << theFace->Tag() << endl;
     
143.         lw->WriteLine(out.str().c_str());
     , a% f3 S# N+ Q2 o$ V9 B% P
144. 
     , s' D' }0 Y, |8 u3 R3 s, |; r
145.         std::vector<Edge*> edges = theFace->GetEdges();
     
146.         out.str(""); out.clear();
     / r- ]4 K9 k( \4 d
147.         out << " Number of edges: " << edges.size() << endl;
     
148.         lw->WriteLine(out.str().c_str());
       i2 _! z* a) g4 k' R
149. 
     
150.         for( int ii = 0; ii < edges.size(); ii++)
     - q& S/ w: I) W1 e7 |
151.         {
     $ R+ z+ d) M. h3 @
152.             out.str(""); out.clear();
     
153.             out << " Edge: " << edges[ii]->Tag() << endl;
     * Q% J( X7 N8 Q& f; o/ Q
154.             lw->WriteLine(out.str().c_str());
     4 z+ Z8 A* c& o6 P! q  |
155. 
     
156.             std::vector< NXOpen::Face * > adj_faces = edges[ii]->GetFaces();
     & n( Y$ K. x, J
157.             out.str(""); out.clear();
     # x% p: l9 i2 Z5 n
158.             out << " Number of adjacent faces: " << adj_faces.size() << endl;
     
159.             lw->WriteLine(out.str().c_str());
     
160. 
       z% g* n- |6 M9 j5 V4 {
161.             for( int jj = 0; jj < adj_faces.size(); jj++)
     , ^, k6 o2 O" A( I, D4 `) }
162.             {
     
163.                 out.str(""); out.clear();
     
164.                 out << " Adjacent face: " << adj_faces[jj]->Tag() << endl;
     - M0 V5 [* ^7 t8 F  z2 R
165.                 lw->WriteLine(out.str().c_str());
     
166. 
     
167.                 myfaces.push_back(adj_faces[jj]);
     
168. 
     
169.             } // jj
     ) v) F7 {; k' w
170. 
     7 v( t  o. L, s  J* ^# v6 |" I0 I
171.         } // ii
     - `4 Y- q1 |2 |8 \
172. 
     
173.         myfaces.unique();
     
174.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     6 a! q* @. k" x6 K5 V
175.         {
     0 s% ]& d# X! S. `/ R- G0 b
176.             (*it)->Highlight();
     7 b% ~, }: ?8 d2 b
177.         }
     - J1 A( @2 E. S& a8 Q7 U3 C. G" y$ k# Y& _
178.         Gtac::theUI->NXMessageBox()->Show("Adjacent Faces", NXOpen::NXMessageBox::DialogTypeInformation, "Confirm");
     ) a2 ]. T4 T$ t
179.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     
180.         {
     0 J2 q8 N, M$ w  d+ ]% ]  A* D( R- J+ Y
181.             (*it)->Unhighlight();
     $ V- T3 D% o. c
182.         }
     ) Y5 m  m( n$ o3 B1 g" e
183.         myfaces.clear();
     
184. 
     
185. 
     4 ^* E4 X: u/ N5 l7 B! I( F
186.     } // while
     6 L5 u* ?% K- F& K' r, m
187. }
     ' r) H4 g  J! Y9 I2 G. `' [
188. 
     
189. //------------------------------------------------------------------------------
     
190. // Entry point for our unmanaged internal C++ program
     
191. //------------------------------------------------------------------------------
     . L* @. a$ ], Y9 X1 n2 k
192. extern DllExport void ufusr( char *parm, int *returnCode, int rlen )
     
193. {
     
194.     try
     
195.     {
     2 J* v9 g$ H4 v9 T2 s$ Q  s
196.         theGtac = new Gtac();
     % Z. d$ H! C8 `0 N; W4 ?
197.         theGtac->do_it();
     4 l1 [- Z2 m- y- o. y
198.         delete theGtac;
     1 f3 T2 t& [/ M& ~
199.     }
     
200.     catch (const NXOpen::NXException& ex)
     
201.     {
     
202.         // ---- Enter your exception handling code here -----
     
203.         Gtac::theUI->NXMessageBox()->Show("CaUGht Error", NXOpen::NXMessageBox::DialogTypeError, ex.Message());
     1 o% ]* `  Y4 Z/ A0 K* N8 m
204.     }
     
205. }
     
206. 
     
207. 
     
208. //------------------------------------------------------------------------------
     
209. // Unload Handler
     1 P. }+ D8 b4 _$ K
210. //------------------------------------------------------------------------------
     0 m& U5 H) [: ?4 @4 V
211. extern "C" DllExport int ufusr_ask_unload()
     
212. {
     6 a0 ~( k0 v4 I& t) N' u. i  x
213. return (int)NXOpen::Session::LibraryUnloadOptionImmediately;
     
214. }
     
215. 
     9 g" d% k* a8 x- }

复制代码