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

admin

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

$ a7 I% ]7 t4 x; Y+ W

1. #include <uf.h>
   $ ~! q( x+ t" y1 c' F- \
2. #include <uf_ui.h>
   
3. #include <uf_object_types.h>
   
4. 
   
5. #include <NXOpen/Edge.hxx>
   , C5 K+ s9 J- j
6. #include <NXOpen/Face.hxx>
   ! S2 a2 s2 `. y  b0 q4 O
7. 
   ; s% }2 _; D" T6 a1 c! z
8. #include <NXOpen/ListingWindow.hxx>
   + P' o$ {9 B  B! t) E3 r& A" _$ o
9. #include <NXOpen/NXException.hxx>
   6 E" H4 y; B' b6 W' `
10. #include <NXOpen/NXMessageBox.hxx>
    
11. #include <NXOpen/NXObject.hxx>
    . A9 G9 q$ V9 ]3 Q* U! D
12. #include <NXOpen/Part.hxx>
    ( X0 ?) N/ N& Z) ~; [, B5 \% C
13. #include <NXOpen/ParTCollection.hxx>
    
14. #include <NXOpen/SelectDisplayableObject.hxx>
    
15. #include <NXOpen/SelectDisplayableObjectList.hxx>
    
16. #include <NXOpen/SelectObject.hxx>
    ! @4 W7 F  ~9 t  K9 n, ]
17. #include <NXOpen/SelectObjectList.hxx>
    * }2 P- a+ B2 e7 r2 a
18. #include <NXOpen/Selection.hxx>
    , D; p3 d+ h5 g: n! r( t" t! R/ g2 u
19. #include <NXOpen/Session.hxx>
    
20. #include <NXOpen/UI.hxx>
    
21. #include <NXOpen/View.hxx>
    
22. 
    9 ^6 v" @: I8 u0 M
23. #include <iostream>
    
24. #include <sstream>
    
25. #include <list>
    
26. 
    ) A5 j! \& E3 `; [! _
27. using namespace NXOpen;
    2 w! a' F; B- R1 R6 y- h+ v, o. K
28. using namespace NXOpen::Annotations;
    / E1 B% q8 q9 u* J" F4 G7 `) t& f4 w  s- K
29. using namespace std;
    2 q) ]( a. b$ U
30. 
    - d; g0 b1 s4 @4 h2 S6 J& J! K% j! |# z
31. class Gtac
    " Z. l$ s3 R9 A: [
32. {
    
33.     // class members
    4 x, F3 a+ `3 x8 x( k
34. public:
    
35.     static Session *theSession;
    6 d, M# m  P0 M/ e6 G; l; x: Q
36.     static UI *theUI;
    
37. 
    + R, t! x6 b* V- d( g5 |8 [
38.     Gtac();
    ( f2 d% j! X; \" m3 D' V
39.     ~Gtac();
    . j  k- i( u( f0 S* _4 I1 a
40. 
    
41.     void do_it();
    1 {' E  j/ L! S) r8 T
42. 
    1 w: ^1 X0 ?! g/ Q7 K
43. private:
    
44.     Part *workPart, *displayPart;
    
45.     Selection *sm;
    " t  o+ R$ T- P: T1 {
46.     NXMessageBox *mb;
    % z+ B2 C; s8 v4 L1 ]
47.     ListingWindow *lw;
    
48. 
    ; [" z, I* s- Q5 o' w: x
49.     Face* select_a_face();
    
50. 
    
51. };
    
52. 
    8 _) `3 T+ _1 G
53. //------------------------------------------------------------------------------
      m' k5 Q  Y8 b. a4 p
54. // Initialize static variables
    5 [0 N! ~! w+ I
55. //------------------------------------------------------------------------------
    
56. Session *(Gtac::theSession) = NULL;
    : g% [7 s! [1 }' g) I: \
57. UI *(Gtac::theUI) = NULL;
    
58. 
    ) y! G( W; H* r6 D. h& k
59. //------------------------------------------------------------------------------
    . J5 u/ U" j" Z! Y3 \& J. M
60. // Declaration of global variables
    / U$ R4 R  P$ W! k9 r
61. //------------------------------------------------------------------------------
    ( Y9 Z) D" }# W# K1 i
62. Gtac *theGtac;
    ( X& S1 y! _  k/ v
63. 
    9 q* `  r5 J% r% s/ Z8 l/ S2 i
64. //------------------------------------------------------------------------------
    
65. // Constructor
    
66. //------------------------------------------------------------------------------
    ; P2 X2 I4 a( C- B3 t
67. Gtac::Gtac()
    $ l' z5 q7 t& V5 F, q0 Y
68. {
    - _. k3 E+ K( E" L2 }8 ^
69.     // Initialize the NX Open C++ API environment
    $ Z9 {7 P& F. Y2 ~. w7 `3 c( g
70.     Gtac::theSession = NXOpen::Session::GetSession();
    ; @( b3 z% ^4 n$ D
71.     Gtac::theUI = UI::GetUI();
    . w6 e0 k" ]2 q# l
72. 
    
73.     sm = theUI->SelectionManager();
    
74.     mb = theUI->NXMessageBox();
    
75.     lw = theSession->ListingWindow();
    " i3 X( q& V6 k! @6 M: m- w+ b, N
76. 
    & a/ V5 G/ z  p- t6 _) l( z
77.     workPart = 0;
    ! h) o6 v0 P+ U1 ~; Z. i0 x
78.     displayPart = 0;
    - E& U8 N; k+ c/ F( `
79. }
    
80. 
    
81. //------------------------------------------------------------------------------
    $ i. G1 }- s6 l! r3 r$ P" l( S
82. // Destructor
    " ^/ E+ N6 Y7 w+ a4 a2 D8 C" c
83. //------------------------------------------------------------------------------
    
84. Gtac::~Gtac()
    
85. {
    
86. }
    
87. 
    
88. //------------------------------------------------------------------------------
    
89. // Selection
    8 D6 e0 d5 d$ i4 b8 u9 A! c  y
90. //------------------------------------------------------------------------------
    
91. Face* Gtac::select_a_face()
    
92. {
    
93.     // ask user to select a face
    
94.     UI *ui = UI::GetUI();
    
95.     Selection *sm = ui->SelectionManager();
    8 t. c: J* L) S1 l$ b8 G3 V
96.     NXMessageBox *mb = ui->NXMessageBox(); // as of NX5
    
97. 
    
98.     NXString message("Select Face:");
    
99.     NXString title("Select Face");
    ( M  f3 P! G- u- E* B+ C, \; E+ a
100.     Selection::SelectionScope scope = Selection::SelectionScopeUseDefault;
     
101.     Selection::SelectionAction action = Selection::SelectionActionClearAndEnableSpecific;
     9 _/ U9 a6 W: {2 s8 t$ W
102.     bool include_features = 0;
     
103.     bool keep_highlighted = 0;
     ! c, e. U2 ~! m1 }
104. 
     ' {+ P/ E0 N6 {6 t
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  );
     ( S( E. u: k9 u3 @& q, a2 N
108.     Point3d cursor;
     8 I* T2 g% f7 s# r. z
109.     NXObject *object;
     3 Z& \* l( c: @5 \! }7 l
110. 
     9 D7 g1 Z5 V, ]& ?$ B' n7 H
111.     // Select objects using filter defined by mask triples
     " ?  B: I# R6 r6 C
112.     Selection::Response res = sm->SelectObject(
     * M$ e+ C( C- l8 E
113.         message, title, scope, action, include_features,
     " e, Q0 A  X! x' W
114.             keep_highlighted, mask, &object, &cursor );
     
115. 
     
116.     if( res == Selection::ResponseObjectSelected )
     
117.     {
     : |9 u( Q, ?) D: d( o) ^
118.         Face *aFace;
     * W. u3 B+ m" N  I
119.         aFace = (Face *)(object);
     
120.         return aFace;
     1 }8 W1 ^% X. l
121.     }
     6 F! g+ W  `% R  X
122. 
     , Z3 l) f; C) A/ c0 C& D
123.     return 0;
     * q, p2 O0 y& p& S
124. }
     
125. 
     
126. //------------------------------------------------------------------------------
     
127. // start with our job...
     0 a) G* N6 x* m2 N
128. //------------------------------------------------------------------------------
     
129. void Gtac::do_it()
     6 b* A% O2 {6 X- E
130. {
     ) ?( b% ^" O, \5 Y
131.     workPart = theSession->Parts()->Work();
       n# o8 p; Z# T+ S2 S
132.     Part *displayPart = theSession->Parts()->Display();
     
133.     stringstream out;
     , a! [+ Z  l" @* X/ M
134. 
     ( ]5 E5 v: c) z% d! C. n+ H
135.     Face *theFace = 0;
     + |. i8 T- T) o8 s
136.     std::list<Face*> myfaces;
     & B% [/ ?7 N* ]( f/ a
137.    
     ) S5 g8 X% d" L4 ]
138.     while( (theFace=select_a_face()) != 0 )
     
139.     {
     
140.         if(! lw->IsOpen() ) lw->Open();
     " n! P% `, X8 A' t
141. 
     
142.         out << "Selected Object: " << theFace->Tag() << endl;
     
143.         lw->WriteLine(out.str().c_str());
     0 G: h4 N! ^' T0 l, D2 O
144. 
     1 ^' U  D! R8 V- q+ a
145.         std::vector<Edge*> edges = theFace->GetEdges();
     
146.         out.str(""); out.clear();
     - j; U! U7 S( T3 Q8 Y3 I) x
147.         out << " Number of edges: " << edges.size() << endl;
     1 a" s  p8 n1 g' ~; M9 B1 e
148.         lw->WriteLine(out.str().c_str());
     
149. 
     
150.         for( int ii = 0; ii < edges.size(); ii++)
     ; M; w  o# u7 _" E% E
151.         {
     
152.             out.str(""); out.clear();
     $ P5 w( s/ T% _3 s1 d( A  p; K
153.             out << " Edge: " << edges[ii]->Tag() << endl;
     
154.             lw->WriteLine(out.str().c_str());
     
155. 
     + a! ?( }) V1 {3 M. q. u% l
156.             std::vector< NXOpen::Face * > adj_faces = edges[ii]->GetFaces();
     
157.             out.str(""); out.clear();
     
158.             out << " Number of adjacent faces: " << adj_faces.size() << endl;
     
159.             lw->WriteLine(out.str().c_str());
     
160. 
     
161.             for( int jj = 0; jj < adj_faces.size(); jj++)
     
162.             {
     
163.                 out.str(""); out.clear();
     
164.                 out << " Adjacent face: " << adj_faces[jj]->Tag() << endl;
     
165.                 lw->WriteLine(out.str().c_str());
     
166. 
     
167.                 myfaces.push_back(adj_faces[jj]);
     
168. 
     
169.             } // jj
     
170. 
     ' @5 |; j; a+ I3 _6 x3 j1 i( z
171.         } // ii
       E. i. T7 H7 J3 H+ \1 J
172. 
     ) C* g2 Q' w3 l
173.         myfaces.unique();
     3 i& n, G8 k# x8 P. z
174.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     : U+ B0 {2 V1 \3 b# T9 B" W
175.         {
     
176.             (*it)->Highlight();
     
177.         }
     4 R, s. e2 p3 [& Q) T4 U: W5 T
178.         Gtac::theUI->NXMessageBox()->Show("Adjacent Faces", NXOpen::NXMessageBox::DialogTypeInformation, "Confirm");
     4 ^# |9 e3 z9 H" i7 d& ]- J
179.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     
180.         {
     
181.             (*it)->Unhighlight();
     
182.         }
     0 a. {4 Y" F4 E6 N/ O, ?
183.         myfaces.clear();
     
184. 
     9 G& C8 l2 y0 ^) J7 T
185. 
     # i8 d1 N8 f) v2 c7 q& p
186.     } // while
     7 n' Z5 w" E' J. l! Z: E
187. }
     * _4 W0 x. ]( ~! g( `: n) N
188. 
     ) g( g- W" s+ x$ H  a
189. //------------------------------------------------------------------------------
     # l  v$ U3 [4 y6 {
190. // Entry point for our unmanaged internal C++ program
     7 Z( D0 a0 J' `1 m/ ?! Y  E
191. //------------------------------------------------------------------------------
     
192. extern DllExport void ufusr( char *parm, int *returnCode, int rlen )
     
193. {
     ! S( p+ V0 Y% t9 D# L3 l. C
194.     try
     , u/ U, |& w) m" o
195.     {
     
196.         theGtac = new Gtac();
     
197.         theGtac->do_it();
     
198.         delete theGtac;
     
199.     }
     
200.     catch (const NXOpen::NXException& ex)
     
201.     {
     
202.         // ---- Enter your exception handling code here -----
     / ^+ F  k  Z0 |& R  _0 I8 S7 t9 u
203.         Gtac::theUI->NXMessageBox()->Show("CaUGht Error", NXOpen::NXMessageBox::DialogTypeError, ex.Message());
     
204.     }
     1 H1 r4 Z- D  I# ]4 e4 `1 }
205. }
     
206. 
     , `  S6 q+ N2 A
207. 
     7 a+ W( d8 E& T# o
208. //------------------------------------------------------------------------------
     
209. // Unload Handler
     
210. //------------------------------------------------------------------------------
     7 g" c, ?+ {8 }, j; B
211. extern "C" DllExport int ufusr_ask_unload()
     & u$ g+ l% p: G4 x& j/ B( `
212. {
     
213. return (int)NXOpen::Session::LibraryUnloadOptionImmediately;
     0 k4 T0 m% _8 J5 _1 b& j
214. }
     
215. 
     

复制代码