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

admin

通过这个代码，可以获取选择面的相邻面的信息
NX open C++中使用了 选择对象 selectobject 函数，通过面获取边数据，通过边获取面，从而得到信息！

1. #include <uf.h>
   
2. #include <uf_ui.h>
   
3. #include <uf_object_types.h>
   
4. 
   
5. #include <NXOpen/Edge.hxx>
   4 f* A% \8 ]8 K9 z) n8 G2 C
6. #include <NXOpen/Face.hxx>
   6 K6 H3 C  G" b4 S8 Y7 N2 j% B; b
7. 
   
8. #include <NXOpen/ListingWindow.hxx>
   8 ~7 x6 j1 Y* I. h4 K
9. #include <NXOpen/NXException.hxx>
   
10. #include <NXOpen/NXMessageBox.hxx>
    ( z0 b- Q  v- [0 a. Q* @! S6 X
11. #include <NXOpen/NXObject.hxx>
    2 h& a' e9 J) w
12. #include <NXOpen/Part.hxx>
    . F* Z2 i& g8 S+ O. c$ l% {- g
13. #include <NXOpen/ParTCollection.hxx>
    6 R' x' w2 `$ {, Y, g  x
14. #include <NXOpen/SelectDisplayableObject.hxx>
    
15. #include <NXOpen/SelectDisplayableObjectList.hxx>
    
16. #include <NXOpen/SelectObject.hxx>
    & j4 F- z' J  V9 r0 `
17. #include <NXOpen/SelectObjectList.hxx>
    
18. #include <NXOpen/Selection.hxx>
    
19. #include <NXOpen/Session.hxx>
    
20. #include <NXOpen/UI.hxx>
    9 z: x/ P# a" |
21. #include <NXOpen/View.hxx>
    0 d8 a3 S! }% X7 X3 {  h
22. 
    
23. #include <iostream>
    
24. #include <sstream>
    
25. #include <list>
    
26. 
    
27. using namespace NXOpen;
    
28. using namespace NXOpen::Annotations;
    
29. using namespace std;
    ; \0 y8 }) |3 u6 S9 i! s3 E
30. 
    5 K1 D5 m$ @+ L& B- s* c
31. class Gtac
    6 b. E. a: ?* F) o1 j* u* Y5 B% D
32. {
    . X. K0 y8 g( u
33.     // class members
    
34. public:
      W/ {$ W: z: _# e: G
35.     static Session *theSession;
    
36.     static UI *theUI;
    : J" G3 s# h" {7 |' b$ B
37. 
    3 ~+ J! v# [7 M0 P- R( t$ W; Z
38.     Gtac();
    
39.     ~Gtac();
    
40. 
    0 ]; v* z9 z! t  g+ D+ J* i
41.     void do_it();
    * C8 t( e: r- i# W
42. 
    " `; k# t0 e0 j: }
43. private:
    
44.     Part *workPart, *displayPart;
    " ^+ ]6 d+ q1 r, }$ U
45.     Selection *sm;
    " r5 [+ _+ E5 j4 q! k
46.     NXMessageBox *mb;
    
47.     ListingWindow *lw;
    
48. 
    
49.     Face* select_a_face();
    
50. 
    3 X$ M* o& d  a, H) y
51. };
    
52. 
    + F9 @  I; L6 l
53. //------------------------------------------------------------------------------
    
54. // Initialize static variables
    
55. //------------------------------------------------------------------------------
    1 R& G+ y% j- Y
56. Session *(Gtac::theSession) = NULL;
    
57. UI *(Gtac::theUI) = NULL;
    % U( i- g# m# u9 \  W! n
58. 
    ) ?: j/ J2 D# A. T
59. //------------------------------------------------------------------------------
    0 `& P$ [+ v% d3 ]" M6 I
60. // Declaration of global variables
    : [* v1 d; k  ?( \' _3 k
61. //------------------------------------------------------------------------------
    
62. Gtac *theGtac;
    
63. 
    ( n1 Q" q6 q4 g- c* G, k& c
64. //------------------------------------------------------------------------------
    
65. // Constructor
    ! M; F' h5 l: J% t; W5 N/ y4 k
66. //------------------------------------------------------------------------------
    
67. Gtac::Gtac()
    9 F7 ~: T" n' s( j2 ?" G. |$ K
68. {
    
69.     // Initialize the NX Open C++ API environment
    
70.     Gtac::theSession = NXOpen::Session::GetSession();
    
71.     Gtac::theUI = UI::GetUI();
    
72. 
    
73.     sm = theUI->SelectionManager();
    
74.     mb = theUI->NXMessageBox();
    
75.     lw = theSession->ListingWindow();
    
76. 
    
77.     workPart = 0;
    & x$ l+ F) T, P; d+ _; X& S  `
78.     displayPart = 0;
    
79. }
    4 w! r/ L7 ]& U# g% D1 M
80. 
    
81. //------------------------------------------------------------------------------
    
82. // Destructor
    
83. //------------------------------------------------------------------------------
      D- S; I0 ^, K) `
84. Gtac::~Gtac()
    
85. {
    
86. }
    
87. 
    
88. //------------------------------------------------------------------------------
    % M) e* [5 b, i- E+ J$ @
89. // Selection
    
90. //------------------------------------------------------------------------------
    & ^1 K+ i1 ~- H- c+ g, G( M8 j, G
91. Face* Gtac::select_a_face()
    
92. {
    
93.     // ask user to select a face
    
94.     UI *ui = UI::GetUI();
    
95.     Selection *sm = ui->SelectionManager();
    
96.     NXMessageBox *mb = ui->NXMessageBox(); // as of NX5
    , O$ K( B* k+ i  y3 e# v  n
97. 
    # K' s" \: _9 T2 n
98.     NXString message("Select Face:");
    3 c* ?; d7 |6 Y6 _$ c9 v( }4 \9 P
99.     NXString title("Select Face");
    
100.     Selection::SelectionScope scope = Selection::SelectionScopeUseDefault;
     9 }- B  |: K* s/ W4 T$ e
101.     Selection::SelectionAction action = Selection::SelectionActionClearAndEnableSpecific;
     % p9 [9 G: r6 C& M  s7 S
102.     bool include_features = 0;
     
103.     bool keep_highlighted = 0;
     
104. 
     
105.     // Define the mask triple(s)
     
106.     std::vector<Selection::MaskTriple> mask(1);
     
107.     mask[0] = Selection::MaskTriple( UF_solid_type, 0, UF_UI_SEL_FEATURE_ANY_FACE  );
     : \' n) z% F1 `$ w. h
108.     Point3d cursor;
     
109.     NXObject *object;
     
110. 
     3 b2 E9 l5 ?' F4 P6 S) {
111.     // Select objects using filter defined by mask triples
     , B  t0 r% _2 W: T
112.     Selection::Response res = sm->SelectObject(
     
113.         message, title, scope, action, include_features,
     
114.             keep_highlighted, mask, &object, &cursor );
     0 c& A' H* V9 s( K8 Q4 p9 ^
115. 
     
116.     if( res == Selection::ResponseObjectSelected )
     
117.     {
     
118.         Face *aFace;
     
119.         aFace = (Face *)(object);
     
120.         return aFace;
     9 e! e# q  C4 i
121.     }
     & V! a  n9 [5 k1 ^8 |+ Y
122. 
     
123.     return 0;
     
124. }
     - w* f% W* b4 o  G& p4 {
125. 
     
126. //------------------------------------------------------------------------------
     7 B1 U# X. s' E  {" f8 O
127. // start with our job...
     6 V. v) X) M6 F* V/ f0 T+ Z. z* c
128. //------------------------------------------------------------------------------
     8 T9 t- n  r; e( f/ u$ L
129. void Gtac::do_it()
     
130. {
     ! N' x; `; Y% F' n6 J
131.     workPart = theSession->Parts()->Work();
     
132.     Part *displayPart = theSession->Parts()->Display();
     $ m( j  v# p# R4 J7 i  U, j0 ^
133.     stringstream out;
     
134. 
     % f, Z  }. T: p( `' T  ^2 T
135.     Face *theFace = 0;
     ( m8 ]6 T; h4 _) q3 A( T/ n
136.     std::list<Face*> myfaces;
     : j1 w- W  D! ^3 b8 S7 Y6 G
137.    
     " P" f) @' B  i. x' r, Y
138.     while( (theFace=select_a_face()) != 0 )
     
139.     {
     ( W$ z! _9 l. i# F1 [) G3 Z
140.         if(! lw->IsOpen() ) lw->Open();
     " L# t2 r2 A1 ~3 ?* x4 V! N# F
141. 
     
142.         out << "Selected Object: " << theFace->Tag() << endl;
     
143.         lw->WriteLine(out.str().c_str());
     
144. 
     5 J* h8 i5 t3 B' C
145.         std::vector<Edge*> edges = theFace->GetEdges();
     : t5 w& }, k( b" e2 b0 _( p+ |
146.         out.str(""); out.clear();
     : _/ I' l) j9 b8 S+ F" T# K6 b
147.         out << " Number of edges: " << edges.size() << endl;
     
148.         lw->WriteLine(out.str().c_str());
     2 M9 _/ g- }% w/ p! I1 O% P( z0 h
149. 
     
150.         for( int ii = 0; ii < edges.size(); ii++)
     + t! P5 z6 d# d( |( {  t: K: @3 ]& s
151.         {
     # M! Y* P$ D- A1 u  o! `% r, p
152.             out.str(""); out.clear();
     
153.             out << " Edge: " << edges[ii]->Tag() << endl;
     
154.             lw->WriteLine(out.str().c_str());
     5 D. P8 M- U/ [" G( \
155. 
     5 C! Y  e5 ]( V% l
156.             std::vector< NXOpen::Face * > adj_faces = edges[ii]->GetFaces();
     
157.             out.str(""); out.clear();
     , j: ?, X9 F( U, l6 f
158.             out << " Number of adjacent faces: " << adj_faces.size() << endl;
     # E" k; ]$ p: {# }
159.             lw->WriteLine(out.str().c_str());
     
160. 
     
161.             for( int jj = 0; jj < adj_faces.size(); jj++)
     ! F) G9 v" x; I4 p8 p! u* b  \+ w
162.             {
     6 m0 n: j" B. d; i" I2 |! X1 E
163.                 out.str(""); out.clear();
     
164.                 out << " Adjacent face: " << adj_faces[jj]->Tag() << endl;
     4 c- j( o; ^+ }; S7 [" a
165.                 lw->WriteLine(out.str().c_str());
     / f: ]' q2 X  J% u$ C# l  a
166. 
     
167.                 myfaces.push_back(adj_faces[jj]);
     
168. 
     
169.             } // jj
     - Y. O, j; F% x$ m4 Z
170. 
     
171.         } // ii
     ; J1 _+ w; F3 p
172. 
     , ]) {  b: p  S2 g7 K
173.         myfaces.unique();
     
174.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     ( ~9 r- [: m0 c% E( q! J
175.         {
     
176.             (*it)->Highlight();
     / p; [' Y% ~6 P) n! _
177.         }
     
178.         Gtac::theUI->NXMessageBox()->Show("Adjacent Faces", NXOpen::NXMessageBox::DialogTypeInformation, "Confirm");
     
179.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     
180.         {
     3 i' C2 Q; R4 Y1 W1 i
181.             (*it)->Unhighlight();
     . a6 E- ]& M/ A* z3 ?9 D6 j
182.         }
     % Z5 _" ]$ `7 u# x3 S+ k
183.         myfaces.clear();
     5 n4 n7 x. y6 M2 o4 k( @7 K. T
184. 
     , u* _( N2 b3 {8 Z
185. 
     
186.     } // while
     
187. }
     
188. 
     * A7 A2 p! |$ l" f( [' e: }
189. //------------------------------------------------------------------------------
     9 {( W6 m7 j4 m- f! e
190. // Entry point for our unmanaged internal C++ program
     
191. //------------------------------------------------------------------------------
     
192. extern DllExport void ufusr( char *parm, int *returnCode, int rlen )
     ; n  L: T+ U: ^. \/ }
193. {
     4 M  q2 C5 F: x: d( b4 Y: \
194.     try
     3 g- m- ?' q( F) j
195.     {
     
196.         theGtac = new Gtac();
     2 ?6 D9 j% A5 n. p% `0 G
197.         theGtac->do_it();
     
198.         delete theGtac;
     5 ^6 g$ z0 s; x
199.     }
     
200.     catch (const NXOpen::NXException& ex)
     
201.     {
     ) O9 H6 F& S& C) f; p1 U4 Y
202.         // ---- Enter your exception handling code here -----
     1 g0 c' u8 g* Z* R( m  X' _
203.         Gtac::theUI->NXMessageBox()->Show("CaUGht Error", NXOpen::NXMessageBox::DialogTypeError, ex.Message());
     
204.     }
     ' o  {- \: M+ `& ^( I9 V4 R7 _- L+ t
205. }
     + Q% ^' L0 m$ ]% f* s
206. 
     8 t( \9 U% F, w4 h/ q
207. 
     ( ]& ]. f/ I# u. \6 y7 g
208. //------------------------------------------------------------------------------
     0 G( V( ~3 M' Z0 L$ X* w! Z0 y5 y% B
209. // Unload Handler
       g4 w8 n& ^* e+ k
210. //------------------------------------------------------------------------------
     
211. extern "C" DllExport int ufusr_ask_unload()
     - m7 A- E0 J9 d$ R! P3 @$ U
212. {
     
213. return (int)NXOpen::Session::LibraryUnloadOptionImmediately;
     & y$ B4 P5 t: Y+ U8 Y4 d
214. }
     
215. 
     8 A% C& m0 r; Z4 J( u! r& {% {

复制代码