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

admin

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

1. #include <uf.h>
   9 O5 w4 p8 Y, Z' g2 N
2. #include <uf_ui.h>
   
3. #include <uf_object_types.h>
   
4. 
   
5. #include <NXOpen/Edge.hxx>
   . Z+ b, f" O" ~. d# P
6. #include <NXOpen/Face.hxx>
     e! f" }' D  ?, ^) M! S% n
7. 
   
8. #include <NXOpen/ListingWindow.hxx>
   # c3 ?& R- N, W6 G# R# {" R
9. #include <NXOpen/NXException.hxx>
   
10. #include <NXOpen/NXMessageBox.hxx>
    $ m, Q8 v3 i6 R9 d) j) S, L
11. #include <NXOpen/NXObject.hxx>
    4 S5 F4 U6 n, h( r/ k
12. #include <NXOpen/Part.hxx>
    7 j/ o/ t/ C1 k8 m! c2 F
13. #include <NXOpen/ParTCollection.hxx>
    
14. #include <NXOpen/SelectDisplayableObject.hxx>
      K: o9 [" Q: `. y- P* b
15. #include <NXOpen/SelectDisplayableObjectList.hxx>
    . B* c1 k' Q7 R
16. #include <NXOpen/SelectObject.hxx>
    
17. #include <NXOpen/SelectObjectList.hxx>
    , L- u9 c* j- E5 ?3 d
18. #include <NXOpen/Selection.hxx>
    
19. #include <NXOpen/Session.hxx>
    % W8 q& b$ d" X2 h
20. #include <NXOpen/UI.hxx>
    
21. #include <NXOpen/View.hxx>
    
22. 
    $ P! \) _2 B2 @- n6 F* m
23. #include <iostream>
    % P, w+ O9 ^" ~
24. #include <sstream>
    
25. #include <list>
    0 M3 u: \7 Y/ Q; c" S2 G
26. 
    
27. using namespace NXOpen;
    
28. using namespace NXOpen::Annotations;
    " ]: U9 _, f6 ?- N
29. using namespace std;
    & N. G  g- |6 W, m& [7 m
30. 
    * p3 L, j( q4 v4 ?1 _
31. class Gtac
    # C3 C/ j1 H7 d% [; {. |0 S" a
32. {
      C, |3 x9 ~' @3 ^$ b
33.     // class members
    . |. T5 |1 X. x# _; l7 @' Q* j3 i
34. public:
    3 _6 A5 Y# h+ I! p
35.     static Session *theSession;
    ! e3 N5 w( R9 n6 O1 V! a7 J
36.     static UI *theUI;
    - _# {1 C. H# V- P4 |
37. 
    , K4 z* N1 p; P* x9 B3 z
38.     Gtac();
    
39.     ~Gtac();
    
40. 
    
41.     void do_it();
    
42. 
    + k9 i8 o& p: N+ u
43. private:
    
44.     Part *workPart, *displayPart;
    - c0 X* h% G! l$ d0 ~1 ~3 k) ~
45.     Selection *sm;
    
46.     NXMessageBox *mb;
    ) D1 H' {2 e+ H0 j+ W
47.     ListingWindow *lw;
    
48. 
    
49.     Face* select_a_face();
    : w' N4 R' _$ @! z; _
50. 
      W  R9 Z2 O" v2 ~; M
51. };
    
52. 
    * J+ L! |$ l4 Z/ l( l- b6 n
53. //------------------------------------------------------------------------------
    
54. // Initialize static variables
    
55. //------------------------------------------------------------------------------
    ! v0 e) h7 I- Y5 G' r5 O& @" V
56. Session *(Gtac::theSession) = NULL;
    2 y, U) a! W0 f" {3 [" C1 ]: `. b0 @
57. UI *(Gtac::theUI) = NULL;
      o! {) I* S5 ?9 h2 m" ^4 q3 a- L( P
58. 
    $ \4 R& E0 a9 M! _5 r
59. //------------------------------------------------------------------------------
    
60. // Declaration of global variables
    
61. //------------------------------------------------------------------------------
    , J* u% T2 h! L+ J  }6 P/ l1 Y% R
62. Gtac *theGtac;
    
63. 
    
64. //------------------------------------------------------------------------------
    
65. // Constructor
    1 X6 Y; [& w6 r1 l8 Y4 l( X
66. //------------------------------------------------------------------------------
    
67. Gtac::Gtac()
    
68. {
    # u/ O: {" W- _# t
69.     // Initialize the NX Open C++ API environment
    
70.     Gtac::theSession = NXOpen::Session::GetSession();
    6 M% z3 h$ ~/ {) O0 V8 |
71.     Gtac::theUI = UI::GetUI();
    
72. 
    
73.     sm = theUI->SelectionManager();
    
74.     mb = theUI->NXMessageBox();
    + t. ]2 u& c; y
75.     lw = theSession->ListingWindow();
    1 F0 r! s- {* f  ?' ?6 R
76. 
    8 B7 ]) N! K/ n# K
77.     workPart = 0;
    
78.     displayPart = 0;
    * N2 j4 k9 b3 j) w4 H
79. }
    ' {( @# c8 s  [! a, N) r
80. 
    ( N+ f0 r/ F% Z8 v6 J
81. //------------------------------------------------------------------------------
    
82. // Destructor
    4 S- E: _. J2 ?- {* A
83. //------------------------------------------------------------------------------
    
84. Gtac::~Gtac()
    
85. {
    9 [6 i' @+ [6 ?5 t1 ]. F5 x0 Y
86. }
    % p9 u/ _0 p! q( L" H/ P( e
87. 
    6 L7 M  Z, X+ _# o
88. //------------------------------------------------------------------------------
    : Y0 t+ L, J- B3 b- p# \* M
89. // Selection
    
90. //------------------------------------------------------------------------------
    # X) D8 w$ @3 {+ y# d% ~- Y
91. Face* Gtac::select_a_face()
    
92. {
    9 m" ^' s# n% ^8 Q& Z: W
93.     // ask user to select a face
    
94.     UI *ui = UI::GetUI();
    ! t' ]% J) e, T
95.     Selection *sm = ui->SelectionManager();
    4 N  Q2 c8 ?% [7 c0 S
96.     NXMessageBox *mb = ui->NXMessageBox(); // as of NX5
    
97. 
    + y- w8 @2 u3 H& \: ?
98.     NXString message("Select Face:");
    4 q$ g& I( ^0 T' E
99.     NXString title("Select Face");
    : X" i& Y( f1 W' A$ K; z& K
100.     Selection::SelectionScope scope = Selection::SelectionScopeUseDefault;
     
101.     Selection::SelectionAction action = Selection::SelectionActionClearAndEnableSpecific;
     ; F( k5 _$ l# u& U3 k) D7 ^2 N
102.     bool include_features = 0;
     
103.     bool keep_highlighted = 0;
     
104. 
     
105.     // Define the mask triple(s)
     + C6 p$ o2 s, ?% J+ h
106.     std::vector<Selection::MaskTriple> mask(1);
     $ m/ i+ y0 p# N
107.     mask[0] = Selection::MaskTriple( UF_solid_type, 0, UF_UI_SEL_FEATURE_ANY_FACE  );
       z0 Y5 L# W" B+ i- @
108.     Point3d cursor;
     ( P7 o8 [1 z+ d+ O
109.     NXObject *object;
     4 ^4 F# T) B5 |$ g5 c
110. 
     
111.     // Select objects using filter defined by mask triples
     
112.     Selection::Response res = sm->SelectObject(
     - M- u6 G+ d0 W8 p+ v
113.         message, title, scope, action, include_features,
     & l8 [, c: ~+ c. e
114.             keep_highlighted, mask, &object, &cursor );
     # T8 D; y6 H2 |8 v$ B  q4 R
115. 
     + T4 M6 l5 m* ~1 A! O1 ~, m7 Y! E( @
116.     if( res == Selection::ResponseObjectSelected )
     
117.     {
     # L. h. V3 I1 X0 f2 Y
118.         Face *aFace;
     ; [) ?# k* i! I
119.         aFace = (Face *)(object);
     
120.         return aFace;
     
121.     }
     
122. 
     + n5 z9 ?# _; o0 }: ]& J3 b
123.     return 0;
     6 B' ^6 R) G' V1 d+ h
124. }
     & p) p. b. b9 o4 \3 q
125. 
     
126. //------------------------------------------------------------------------------
     
127. // start with our job...
     $ Q! K' i* p6 B, Z2 B
128. //------------------------------------------------------------------------------
     ' P/ x1 b" i, Z* J$ i4 t4 C2 T
129. void Gtac::do_it()
     ) |* q& b% K' J
130. {
     
131.     workPart = theSession->Parts()->Work();
     2 ~6 E; V" n" {+ A9 _. W
132.     Part *displayPart = theSession->Parts()->Display();
     % F( W( F+ ^; P: D$ v; ]' h7 E" Z
133.     stringstream out;
     # k9 X" ]' C( w$ y8 B
134. 
     0 y. W  y& O! [; W8 ?# T
135.     Face *theFace = 0;
     2 ~1 }5 v" C0 Z( b' V& Z) b" i0 O9 Y
136.     std::list<Face*> myfaces;
     : [6 Y# W+ a& I' p6 Q
137.    
     ' D- w, ~6 I* v
138.     while( (theFace=select_a_face()) != 0 )
     
139.     {
     
140.         if(! lw->IsOpen() ) lw->Open();
     1 |: r) L. ^- q( C- Y" J
141. 
     " L) v% S7 m1 r; C
142.         out << "Selected Object: " << theFace->Tag() << endl;
     
143.         lw->WriteLine(out.str().c_str());
     
144. 
     
145.         std::vector<Edge*> edges = theFace->GetEdges();
     
146.         out.str(""); out.clear();
     & g, S- f3 i& [; ]: |" P+ W
147.         out << " Number of edges: " << edges.size() << endl;
     
148.         lw->WriteLine(out.str().c_str());
     
149. 
     5 D% a- a9 m5 M9 ~) x) k- W
150.         for( int ii = 0; ii < edges.size(); ii++)
     # w. T! R3 p; [! l, y4 V2 R
151.         {
     
152.             out.str(""); out.clear();
     9 k7 w& v6 d/ j) g4 {# v5 x# m
153.             out << " Edge: " << edges[ii]->Tag() << endl;
     1 ]! _& @8 J! K" B# z4 ]
154.             lw->WriteLine(out.str().c_str());
     ) @& a+ }; r+ {7 L8 m
155. 
     
156.             std::vector< NXOpen::Face * > adj_faces = edges[ii]->GetFaces();
       c; }, ?/ [, I1 h1 p
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++)
     / v& X6 Y7 w% m9 H
162.             {
     
163.                 out.str(""); out.clear();
     
164.                 out << " Adjacent face: " << adj_faces[jj]->Tag() << endl;
     
165.                 lw->WriteLine(out.str().c_str());
     & E& Q, s% \; D  P$ S
166. 
     
167.                 myfaces.push_back(adj_faces[jj]);
     
168. 
     
169.             } // jj
     ) y, o' ^3 q8 J2 Q4 S. n
170. 
     
171.         } // ii
     
172. 
     
173.         myfaces.unique();
     3 L0 H1 s7 H( S$ l
174.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     
175.         {
     
176.             (*it)->Highlight();
     . d) K' q1 B7 a; w! U7 k/ d
177.         }
     - U3 V8 K( A$ f
178.         Gtac::theUI->NXMessageBox()->Show("Adjacent Faces", NXOpen::NXMessageBox::DialogTypeInformation, "Confirm");
     
179.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     5 _  v  F$ ~5 r6 {  P( |6 o
180.         {
     
181.             (*it)->Unhighlight();
     9 u3 ?4 Y: G) D( K' f% n
182.         }
     
183.         myfaces.clear();
     
184. 
     1 E3 [$ ~6 m4 A. }2 p
185. 
     , z4 g5 w7 g  s* P' s  S+ y
186.     } // while
     ( A' S9 B8 m+ m% z( B
187. }
     
188. 
     
189. //------------------------------------------------------------------------------
     
190. // Entry point for our unmanaged internal C++ program
     
191. //------------------------------------------------------------------------------
     
192. extern DllExport void ufusr( char *parm, int *returnCode, int rlen )
     
193. {
     
194.     try
     
195.     {
     " u* W$ ^( T% y  k4 i* M
196.         theGtac = new Gtac();
     
197.         theGtac->do_it();
     8 x( k& o$ w1 ?, D
198.         delete theGtac;
     1 m! j8 x4 U8 {( X1 |
199.     }
     
200.     catch (const NXOpen::NXException& ex)
     " T% J+ _+ l: I
201.     {
     
202.         // ---- Enter your exception handling code here -----
     9 A! Z5 v3 }; ^3 P- m; u
203.         Gtac::theUI->NXMessageBox()->Show("CaUGht Error", NXOpen::NXMessageBox::DialogTypeError, ex.Message());
     
204.     }
     2 E) W" l; A9 `% |6 e1 r
205. }
     ! e* ]5 Y/ O5 ]
206. 
     2 A0 G- e- ]/ D
207. 
     4 P) m% x# U* J7 T. m( G
208. //------------------------------------------------------------------------------
     
209. // Unload Handler
     5 }3 E! ~( J; N3 `4 ]+ \8 I- e
210. //------------------------------------------------------------------------------
     
211. extern "C" DllExport int ufusr_ask_unload()
     , s9 Y7 ^* I5 X+ j) z+ j" y
212. {
     ' }1 v. J* ]. b
213. return (int)NXOpen::Session::LibraryUnloadOptionImmediately;
     # u/ K$ \! Z- }4 L) u/ ^
214. }
       L" l  B" E+ ?
215. 
     - K  y) N5 x5 A' B9 C! F4 g1 `2 J" i% k

复制代码