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

admin

通过这个代码，可以获取选择面的相邻面的信息
NX open C++中使用了 选择对象 selectobject 函数，通过面获取边数据，通过边获取面，从而得到信息！
" {* d1 K: [3 j; |

1. #include <uf.h>
   , N" m2 }/ V9 y! m
2. #include <uf_ui.h>
   0 ?3 v$ j& @/ j8 n) c
3. #include <uf_object_types.h>
   
4. 
   
5. #include <NXOpen/Edge.hxx>
   
6. #include <NXOpen/Face.hxx>
   
7. 
   
8. #include <NXOpen/ListingWindow.hxx>
   
9. #include <NXOpen/NXException.hxx>
   4 y& d$ D! r. ^: d4 `% Z  L3 C$ O
10. #include <NXOpen/NXMessageBox.hxx>
    
11. #include <NXOpen/NXObject.hxx>
    
12. #include <NXOpen/Part.hxx>
    
13. #include <NXOpen/ParTCollection.hxx>
    8 @% j) Q: s# z
14. #include <NXOpen/SelectDisplayableObject.hxx>
    
15. #include <NXOpen/SelectDisplayableObjectList.hxx>
    
16. #include <NXOpen/SelectObject.hxx>
    5 J3 G( ~8 O4 _
17. #include <NXOpen/SelectObjectList.hxx>
    % ?; N3 r  j  {% S# y9 `
18. #include <NXOpen/Selection.hxx>
    7 U( b6 `" O$ y1 n; x- _& p
19. #include <NXOpen/Session.hxx>
    ; d3 \% l2 k4 s3 v3 ?0 J1 y/ W
20. #include <NXOpen/UI.hxx>
    
21. #include <NXOpen/View.hxx>
    " n: p  |7 g7 Q; @2 F+ W
22. 
    2 m4 Z: s" M9 _2 K9 C' c
23. #include <iostream>
    * |1 E( c' o2 w2 m% |8 Y
24. #include <sstream>
    1 T. [) G/ {* `
25. #include <list>
    ; D8 j7 v" P) O0 ^& s  @, b
26. 
    
27. using namespace NXOpen;
    , A# B* y6 U# `, j! e2 m
28. using namespace NXOpen::Annotations;
    0 ?* }. ?- {" O5 T7 B" T
29. using namespace std;
    % h% i3 a! f7 T- n, W
30. 
    / u, J" M+ T2 {# w( N
31. class Gtac
    
32. {
    . W& g( I- k" P9 |2 A' y  h, }
33.     // class members
    
34. public:
    
35.     static Session *theSession;
    , U+ G8 @0 q6 R' K" Z: E
36.     static UI *theUI;
    ; U+ V8 t: x! D" K
37. 
    ! |" t/ W/ |) d- ^1 V
38.     Gtac();
    
39.     ~Gtac();
    
40. 
    5 }" S2 I' t7 f& X
41.     void do_it();
    
42. 
    
43. private:
    ) u& [! k/ k' @
44.     Part *workPart, *displayPart;
    
45.     Selection *sm;
      G! L0 f1 v) d4 F
46.     NXMessageBox *mb;
    
47.     ListingWindow *lw;
    . U( [6 p6 ^8 r, f) C+ a
48. 
    
49.     Face* select_a_face();
    
50. 
    + ]* k( Y6 X- j- K/ A) P5 b
51. };
    4 K: K5 @$ j, v) P' p0 s. X; H
52. 
    
53. //------------------------------------------------------------------------------
    7 B; G3 ^5 a  w  w) K
54. // Initialize static variables
    
55. //------------------------------------------------------------------------------
    
56. Session *(Gtac::theSession) = NULL;
    
57. UI *(Gtac::theUI) = NULL;
    
58. 
    4 E' }+ ]+ S+ |/ B; I
59. //------------------------------------------------------------------------------
    
60. // Declaration of global variables
    
61. //------------------------------------------------------------------------------
    
62. Gtac *theGtac;
    
63. 
    ; t1 k3 V6 F4 g! q: T" Z3 R
64. //------------------------------------------------------------------------------
    
65. // Constructor
    2 b- n+ A* @: m3 C* _
66. //------------------------------------------------------------------------------
    
67. Gtac::Gtac()
    " f5 p8 e& |- U
68. {
    & Q: D8 @; H. I  S- b& H7 q  ~
69.     // Initialize the NX Open C++ API environment
    
70.     Gtac::theSession = NXOpen::Session::GetSession();
    
71.     Gtac::theUI = UI::GetUI();
    
72. 
    % C9 b" Z, F, J5 L+ k
73.     sm = theUI->SelectionManager();
    
74.     mb = theUI->NXMessageBox();
      n  s: C6 _) }* k0 V
75.     lw = theSession->ListingWindow();
    ( V4 v! A! H% t/ D8 e8 n) r8 L) z$ p
76. 
    . H# X! P+ G! }9 S. p) H
77.     workPart = 0;
    
78.     displayPart = 0;
    
79. }
    ' t) Z- _6 d( B8 k
80. 
    
81. //------------------------------------------------------------------------------
    
82. // Destructor
    
83. //------------------------------------------------------------------------------
    
84. Gtac::~Gtac()
    
85. {
    * X' k! x  D3 j& K% f  u6 R
86. }
    5 S3 q+ G7 |1 D
87. 
    
88. //------------------------------------------------------------------------------
    
89. // Selection
    
90. //------------------------------------------------------------------------------
    
91. Face* Gtac::select_a_face()
    
92. {
    
93.     // ask user to select a face
    7 X: u( y+ p8 ]7 H
94.     UI *ui = UI::GetUI();
    5 ?) Z% ~  v& |; M+ m9 M/ G+ F
95.     Selection *sm = ui->SelectionManager();
    
96.     NXMessageBox *mb = ui->NXMessageBox(); // as of NX5
    
97. 
    
98.     NXString message("Select Face:");
    ! M2 {0 B. e: q' G$ Z" z% E
99.     NXString title("Select Face");
    , D; z5 ~4 }4 g: l7 E
100.     Selection::SelectionScope scope = Selection::SelectionScopeUseDefault;
     ! M3 V7 K9 p0 o' X4 L
101.     Selection::SelectionAction action = Selection::SelectionActionClearAndEnableSpecific;
     
102.     bool include_features = 0;
     - D5 c3 X. U0 f0 a; C
103.     bool keep_highlighted = 0;
     & D) I+ r, d% }6 A8 \
104. 
     . J6 \  V, X' t% i: R( z- c+ Y
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  );
     2 ^. t: M. L; N  g: X) G: u
108.     Point3d cursor;
     ( L1 v% l* j+ ]8 k0 \' H. G
109.     NXObject *object;
     ( ]( u, Y  S4 n. |. j5 q) C
110. 
     
111.     // Select objects using filter defined by mask triples
     
112.     Selection::Response res = sm->SelectObject(
     8 M+ Y* l# K. M4 u2 ~# z( V: o: T
113.         message, title, scope, action, include_features,
     
114.             keep_highlighted, mask, &object, &cursor );
     2 z7 F# c% h* [3 [& P
115. 
     9 s1 q- r. ], f/ K- \& T
116.     if( res == Selection::ResponseObjectSelected )
     6 n. S& r* y; Y
117.     {
     
118.         Face *aFace;
     
119.         aFace = (Face *)(object);
     3 ]# e" I$ `9 L' d; j7 P
120.         return aFace;
     ; B: p* @2 Q% ?, g. D1 @& X* `
121.     }
     , H+ G# Z- Q9 _5 c. v* P
122. 
     # P; a+ s; L) [+ \1 d: w
123.     return 0;
     % G. C% F+ c8 M7 _$ \0 A& y0 M  a$ `
124. }
     % m8 s8 a" a" G% r0 K
125. 
     9 p4 ~/ x: r- T
126. //------------------------------------------------------------------------------
     
127. // start with our job...
     3 `+ n, s$ d- R
128. //------------------------------------------------------------------------------
     
129. void Gtac::do_it()
     
130. {
     ( A5 W; K1 |* J" D+ W& M" S
131.     workPart = theSession->Parts()->Work();
     7 q5 S: K; j4 F. n4 t
132.     Part *displayPart = theSession->Parts()->Display();
     / b: _, y9 a( J5 i. ?% [
133.     stringstream out;
     
134. 
     
135.     Face *theFace = 0;
     
136.     std::list<Face*> myfaces;
     
137.    
     5 q' c7 B6 y: Y* F
138.     while( (theFace=select_a_face()) != 0 )
     
139.     {
     
140.         if(! lw->IsOpen() ) lw->Open();
     
141. 
     1 w9 V; p0 D5 s; F" O7 ]( G! s
142.         out << "Selected Object: " << theFace->Tag() << endl;
     ) ]" ]/ U) X' C" ]/ x8 ?
143.         lw->WriteLine(out.str().c_str());
     
144. 
     4 H3 S- g0 N, W* f6 m( a: J$ ]
145.         std::vector<Edge*> edges = theFace->GetEdges();
     % p/ z% v6 o- O/ M
146.         out.str(""); out.clear();
     ) U5 p! t1 V; W( B
147.         out << " Number of edges: " << edges.size() << endl;
     , X! H$ W  K& P. a+ l/ i3 W" j2 E
148.         lw->WriteLine(out.str().c_str());
     8 k+ s& [  p2 e/ A1 V$ L- f% f
149. 
     ( u0 V- N5 Q: t, o! d" f
150.         for( int ii = 0; ii < edges.size(); ii++)
     5 }/ T( i% ~  b) ~
151.         {
     - }. w6 Z! l& D5 a
152.             out.str(""); out.clear();
     
153.             out << " Edge: " << edges[ii]->Tag() << endl;
     $ f7 C1 K' H' Z" i( T
154.             lw->WriteLine(out.str().c_str());
     
155. 
     7 `' |4 l8 }% l" i8 ~8 y
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. 
     : T/ v7 p, u# F/ k1 d! O! z
161.             for( int jj = 0; jj < adj_faces.size(); jj++)
     
162.             {
     + y% H, ]; |2 L
163.                 out.str(""); out.clear();
     
164.                 out << " Adjacent face: " << adj_faces[jj]->Tag() << endl;
     3 l  t; \9 S( z9 n
165.                 lw->WriteLine(out.str().c_str());
       ?$ z6 y- J. L" B4 {5 \
166. 
     
167.                 myfaces.push_back(adj_faces[jj]);
     
168. 
     6 Y" l3 W8 f" ~. n/ |$ V& B! H
169.             } // jj
     / m& |1 J: ]6 {6 f( {
170. 
     
171.         } // ii
     
172. 
     / a0 c1 L% K0 f! ], {/ e
173.         myfaces.unique();
     
174.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     - x' }! n# E( E  S  l; @
175.         {
     4 S. b; n( C; C8 }
176.             (*it)->Highlight();
     # ^6 i  m4 j  Z% A! E- |0 s$ s1 _
177.         }
     
178.         Gtac::theUI->NXMessageBox()->Show("Adjacent Faces", NXOpen::NXMessageBox::DialogTypeInformation, "Confirm");
       Y* m; A* v  ^; L: Z
179.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     
180.         {
     
181.             (*it)->Unhighlight();
     
182.         }
     
183.         myfaces.clear();
     
184. 
     2 q, h! j! b5 l7 }) a* B
185. 
     7 Z8 @; ^9 l( }  O  `1 B& I
186.     } // while
     0 R) M; h# \* B0 ^
187. }
     % m1 |; ]" U- }
188. 
     & i0 d3 Y7 a6 M3 _( M
189. //------------------------------------------------------------------------------
     9 v, y" q  J! n2 P6 O2 L
190. // Entry point for our unmanaged internal C++ program
     
191. //------------------------------------------------------------------------------
     
192. extern DllExport void ufusr( char *parm, int *returnCode, int rlen )
     6 o% }; H8 j" @0 ^7 `5 |
193. {
     
194.     try
     9 ^" R1 a) H4 ?; l6 M' V
195.     {
     
196.         theGtac = new Gtac();
     - O; @' I; h1 d( S
197.         theGtac->do_it();
     
198.         delete theGtac;
     
199.     }
     : m6 Q7 x6 a. c$ e$ A) C
200.     catch (const NXOpen::NXException& ex)
     
201.     {
     / H% `9 Q6 P, L8 s; u" m
202.         // ---- Enter your exception handling code here -----
     
203.         Gtac::theUI->NXMessageBox()->Show("CaUGht Error", NXOpen::NXMessageBox::DialogTypeError, ex.Message());
     
204.     }
     1 G( A! w, q/ z8 b4 [' p8 l! s$ k0 y
205. }
     - F$ \& i# W% a5 W; ^& G
206. 
     & x! G* @9 |6 n& U
207. 
     
208. //------------------------------------------------------------------------------
     
209. // Unload Handler
     - J! h  Z% |! J2 a1 C+ n
210. //------------------------------------------------------------------------------
     
211. extern "C" DllExport int ufusr_ask_unload()
     . s3 z# h  }' o4 S& O" Z0 w
212. {
     2 ]; u+ W. l* [
213. return (int)NXOpen::Session::LibraryUnloadOptionImmediately;
     $ Q$ H, N8 B) r
214. }
     
215. 
     

复制代码