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

admin

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

% W1 i- Z! E4 T' g- \

1. #include <uf.h>
   
2. #include <uf_ui.h>
   
3. #include <uf_object_types.h>
   
4. 
   6 E) p6 _% f3 ^7 L' a) Q; G- X
5. #include <NXOpen/Edge.hxx>
   ( }# ?4 t& P6 }3 k  r% N
6. #include <NXOpen/Face.hxx>
   ( L0 {$ Q! P9 ]' l/ I( B
7. 
   
8. #include <NXOpen/ListingWindow.hxx>
   % s. n0 Q  _! b; |
9. #include <NXOpen/NXException.hxx>
   
10. #include <NXOpen/NXMessageBox.hxx>
    
11. #include <NXOpen/NXObject.hxx>
    
12. #include <NXOpen/Part.hxx>
    / j) s* k6 i. l* e2 P! K& m
13. #include <NXOpen/ParTCollection.hxx>
    
14. #include <NXOpen/SelectDisplayableObject.hxx>
    
15. #include <NXOpen/SelectDisplayableObjectList.hxx>
    
16. #include <NXOpen/SelectObject.hxx>
    
17. #include <NXOpen/SelectObjectList.hxx>
    5 l) y! S) m2 n
18. #include <NXOpen/Selection.hxx>
    - S1 R% x8 V0 W- G7 b
19. #include <NXOpen/Session.hxx>
    + b2 G/ _+ A/ {$ F1 n8 ?) t
20. #include <NXOpen/UI.hxx>
    9 s( ?, W# X' r0 x5 P
21. #include <NXOpen/View.hxx>
    
22. 
    2 l( n5 N$ b+ Q
23. #include <iostream>
    
24. #include <sstream>
    
25. #include <list>
    
26. 
    / ?& t! w7 |; S2 `
27. using namespace NXOpen;
    
28. using namespace NXOpen::Annotations;
    ! v! w' o8 q! l- h4 Q0 @
29. using namespace std;
    
30. 
    * z0 u- {8 r/ k2 I9 w2 m5 Q+ j% j3 B
31. class Gtac
    
32. {
    
33.     // class members
    
34. public:
    
35.     static Session *theSession;
    ( x+ E4 o- F# d* ^- z: T, M
36.     static UI *theUI;
    
37. 
    9 R$ f: B* A0 G2 u1 M, V. f
38.     Gtac();
    
39.     ~Gtac();
    
40. 
    
41.     void do_it();
    
42. 
    + X& n3 o9 c' ^5 |* c8 T5 ^
43. private:
    
44.     Part *workPart, *displayPart;
    . {1 K1 @, H8 c( y2 n6 e
45.     Selection *sm;
    
46.     NXMessageBox *mb;
    9 S5 }" A1 S8 U8 Q7 a) P
47.     ListingWindow *lw;
    6 s! r- g. ^4 W
48. 
    
49.     Face* select_a_face();
    % M% D. ^4 h. [3 ~1 U( b8 ]) z
50. 
    ' i+ ~/ T! k% ]: g
51. };
    - A: r- l- o- W1 ^
52. 
    
53. //------------------------------------------------------------------------------
    2 G7 f1 B/ n) [3 j
54. // Initialize static variables
    
55. //------------------------------------------------------------------------------
    
56. Session *(Gtac::theSession) = NULL;
    + c2 {4 n8 f9 [
57. UI *(Gtac::theUI) = NULL;
    
58. 
    
59. //------------------------------------------------------------------------------
    
60. // Declaration of global variables
    & Z' q, L7 `9 K# ?( v9 I# m
61. //------------------------------------------------------------------------------
    / @6 p! r, A: c
62. Gtac *theGtac;
    
63. 
    
64. //------------------------------------------------------------------------------
    # T0 g# \; i! a) O7 \6 x3 `
65. // Constructor
    7 A9 `4 b6 K  X& G" `5 V' ^  R
66. //------------------------------------------------------------------------------
    7 _" e. i, d% e9 g
67. Gtac::Gtac()
    
68. {
    
69.     // Initialize the NX Open C++ API environment
    ' \& y7 A0 g3 o1 t, r
70.     Gtac::theSession = NXOpen::Session::GetSession();
    
71.     Gtac::theUI = UI::GetUI();
    5 ?' k; `6 z, t; C" z
72. 
    
73.     sm = theUI->SelectionManager();
    $ E! z( g, `8 W
74.     mb = theUI->NXMessageBox();
    1 s& ]- V3 f. ]! j# A( S
75.     lw = theSession->ListingWindow();
    
76. 
    
77.     workPart = 0;
    ) a" W' |* j& t( F
78.     displayPart = 0;
    # e; W1 o4 V% Z$ @8 t- ~# v
79. }
    3 S; W& ]- f3 N  ^
80. 
    
81. //------------------------------------------------------------------------------
    % u/ L3 ~4 j; f9 B9 s9 t  [
82. // Destructor
    3 A/ l4 H5 W6 l! m7 g
83. //------------------------------------------------------------------------------
    
84. Gtac::~Gtac()
    " Q0 Y: m( y! q+ F+ M8 V
85. {
    
86. }
    
87. 
    4 S( ?6 Z6 o1 z) l5 }6 [/ R$ t
88. //------------------------------------------------------------------------------
    3 d( H7 X4 f0 @; o' x
89. // Selection
    , }: N3 m" x* H  G8 _. {$ {
90. //------------------------------------------------------------------------------
    
91. Face* Gtac::select_a_face()
    
92. {
    : A8 P. @5 o2 ~4 l( b* n/ c
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
    ( u8 o: |) E* c5 T) t+ |
97. 
    
98.     NXString message("Select Face:");
    
99.     NXString title("Select Face");
    + o3 v( o* @# L; _6 O5 V7 `
100.     Selection::SelectionScope scope = Selection::SelectionScopeUseDefault;
     * R2 @1 x/ O: H4 J7 z2 |" p; z. @
101.     Selection::SelectionAction action = Selection::SelectionActionClearAndEnableSpecific;
     9 d4 B7 M8 p; ^5 V# Q, `
102.     bool include_features = 0;
     
103.     bool keep_highlighted = 0;
     
104. 
     % F! r3 R0 Y8 w4 ~' r! y; ^8 K$ D
105.     // Define the mask triple(s)
     2 h" v7 n! {: @5 [0 m- M# r
106.     std::vector<Selection::MaskTriple> mask(1);
     
107.     mask[0] = Selection::MaskTriple( UF_solid_type, 0, UF_UI_SEL_FEATURE_ANY_FACE  );
     6 f/ @+ Y1 h& t8 s1 n: T8 o
108.     Point3d cursor;
       T- ?/ H% z  C9 B! \" Z
109.     NXObject *object;
     " b6 p, b% _. ~2 J
110. 
     - q: f( z3 G3 o4 A9 G8 K) O, D& l
111.     // Select objects using filter defined by mask triples
     : h* E( Z7 }6 x8 [" Z  ~4 T
112.     Selection::Response res = sm->SelectObject(
     
113.         message, title, scope, action, include_features,
     
114.             keep_highlighted, mask, &object, &cursor );
     
115. 
     ( I3 D# \3 `. s7 z2 c
116.     if( res == Selection::ResponseObjectSelected )
     
117.     {
     
118.         Face *aFace;
     ; Y, L' r7 N. j& X0 z- ~
119.         aFace = (Face *)(object);
     
120.         return aFace;
     
121.     }
     4 S, N2 p3 F. `5 |' k
122. 
     , @" I6 d+ h9 b( P
123.     return 0;
     8 |2 ^/ k, V) c) Z3 y& S6 m& D7 Q
124. }
     + X% i" m3 `% k% c
125. 
     3 q& u: }! s3 c% C# f1 {
126. //------------------------------------------------------------------------------
     
127. // start with our job...
     ) T/ ?0 A2 T; i2 W3 \+ G
128. //------------------------------------------------------------------------------
     ) u* V/ j4 y4 }  J( u9 s$ d- u
129. void Gtac::do_it()
     
130. {
     
131.     workPart = theSession->Parts()->Work();
     8 k8 _: D% e8 p) e4 _) H
132.     Part *displayPart = theSession->Parts()->Display();
     $ t9 }3 N3 m4 }
133.     stringstream out;
     
134. 
     
135.     Face *theFace = 0;
     # \. B: x5 r" A- N* o* |5 c
136.     std::list<Face*> myfaces;
     8 c$ \% c/ M: v5 `' N9 C
137.    
     
138.     while( (theFace=select_a_face()) != 0 )
     
139.     {
     
140.         if(! lw->IsOpen() ) lw->Open();
     
141. 
     
142.         out << "Selected Object: " << theFace->Tag() << endl;
     
143.         lw->WriteLine(out.str().c_str());
     
144. 
     4 {7 E, S' ^4 k. i
145.         std::vector<Edge*> edges = theFace->GetEdges();
     
146.         out.str(""); out.clear();
     
147.         out << " Number of edges: " << edges.size() << endl;
     4 [( H2 ]; f/ g5 B- t4 }- J
148.         lw->WriteLine(out.str().c_str());
     
149. 
     6 F- S. Z+ v7 V$ b8 D! j8 N& t
150.         for( int ii = 0; ii < edges.size(); ii++)
     ' u" ~0 v) C8 k! ^" f
151.         {
     
152.             out.str(""); out.clear();
     $ B0 J8 a4 p: o$ ^. |$ ~! O
153.             out << " Edge: " << edges[ii]->Tag() << endl;
     
154.             lw->WriteLine(out.str().c_str());
     . a  g* @$ R. Q4 y" _4 @8 z4 h
155. 
     
156.             std::vector< NXOpen::Face * > adj_faces = edges[ii]->GetFaces();
     ( `  {+ |+ u  r, w* X2 h& y
157.             out.str(""); out.clear();
     
158.             out << " Number of adjacent faces: " << adj_faces.size() << endl;
     % k. ~4 S0 _# o& y6 ]! U
159.             lw->WriteLine(out.str().c_str());
     
160. 
     
161.             for( int jj = 0; jj < adj_faces.size(); jj++)
     
162.             {
     
163.                 out.str(""); out.clear();
     , L# N7 u8 p  w4 s$ Y1 A
164.                 out << " Adjacent face: " << adj_faces[jj]->Tag() << endl;
     ' ?# C1 _( s  U, I
165.                 lw->WriteLine(out.str().c_str());
     # q4 U9 _  Y( X, l
166. 
     0 }7 f+ }8 x) w. l) e; q
167.                 myfaces.push_back(adj_faces[jj]);
     6 L3 b1 U4 r/ B# i
168. 
     7 u+ ^# R' J0 T1 x* Z/ q" l
169.             } // jj
     0 \% {6 r# @+ H* v
170. 
     " }/ x/ x  I/ X0 `6 G! X" R. b9 Z" _
171.         } // ii
     
172. 
     5 W8 }) L/ L+ J# W8 g
173.         myfaces.unique();
     
174.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     
175.         {
     
176.             (*it)->Highlight();
     7 ?7 {; P- k7 [6 {/ c& z, s) e7 q
177.         }
     3 T  V! O- t) h+ f: N2 j" b2 f
178.         Gtac::theUI->NXMessageBox()->Show("Adjacent Faces", NXOpen::NXMessageBox::DialogTypeInformation, "Confirm");
     
179.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     ( u8 Q7 Z# L7 Q: W
180.         {
     
181.             (*it)->Unhighlight();
     6 w  Z* \1 T% K& K9 i* z3 M7 y
182.         }
     ; P$ I! A, B" ~+ Y) b- ?5 W- ?" q! C* U
183.         myfaces.clear();
     
184. 
     9 W0 m- ]- P" A. m+ ?$ r5 P, Y
185. 
       |! {8 h6 R& Q0 q0 c
186.     } // while
     
187. }
     
188. 
     / x" V4 a9 a! N8 W0 P1 f2 |' t
189. //------------------------------------------------------------------------------
     + U  P* R+ ^( U
190. // Entry point for our unmanaged internal C++ program
     3 q3 A; ?: J5 [  i- ?; _" w9 \
191. //------------------------------------------------------------------------------
     ( B! f' F; ~3 p
192. extern DllExport void ufusr( char *parm, int *returnCode, int rlen )
     
193. {
     / w5 {, F$ Y; W: ?
194.     try
     # ]: K; N) _# P6 Q
195.     {
       M5 V  F3 g+ E! t1 K; C
196.         theGtac = new Gtac();
     + N* L5 B( q  y  h% @
197.         theGtac->do_it();
     
198.         delete theGtac;
     
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());
     
204.     }
     , D8 v7 C% Q" X
205. }
     
206. 
     1 A6 |- b8 z- @; h- L$ m
207. 
     
208. //------------------------------------------------------------------------------
     ' g  u) j2 u( N* K- {, L( f1 f9 c
209. // Unload Handler
     
210. //------------------------------------------------------------------------------
     # R+ f' v# ?- m* S! _# A, K
211. extern "C" DllExport int ufusr_ask_unload()
     ) |- {$ r& l+ w
212. {
     
213. return (int)NXOpen::Session::LibraryUnloadOptionImmediately;
     7 v( @. f) s. X9 X+ Q  i6 q
214. }
     " y6 \/ M" z4 M8 h& N' B0 [( N
215. 
     ) N& m: Y. K6 y( k0 ~% j% b

复制代码