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

admin

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

% B  k7 p' `3 ?

1. #include <uf.h>
   
2. #include <uf_ui.h>
   
3. #include <uf_object_types.h>
   / @- ^+ K6 N# w; L
4. 
   5 s& |: U: n; @4 o- [
5. #include <NXOpen/Edge.hxx>
   % U% C* r" C$ f) b* `8 L5 R! r2 \
6. #include <NXOpen/Face.hxx>
   % A$ X) R$ z8 W& v
7. 
   5 @4 ^! _3 V! X8 v* W' B
8. #include <NXOpen/ListingWindow.hxx>
   7 C9 K1 k0 K4 s( H6 I1 E0 K3 N
9. #include <NXOpen/NXException.hxx>
     G4 S) t4 E4 @5 s/ j2 k% T
10. #include <NXOpen/NXMessageBox.hxx>
    ) ?2 L6 {' B, `" O' C* a! }# H
11. #include <NXOpen/NXObject.hxx>
    
12. #include <NXOpen/Part.hxx>
    
13. #include <NXOpen/ParTCollection.hxx>
    
14. #include <NXOpen/SelectDisplayableObject.hxx>
    1 P! V0 E6 k) g2 D# ^4 a/ w7 M% h
15. #include <NXOpen/SelectDisplayableObjectList.hxx>
    ; D$ X0 K: T) m$ ?
16. #include <NXOpen/SelectObject.hxx>
    " w  k) @  ?2 A: v9 Q3 x
17. #include <NXOpen/SelectObjectList.hxx>
    $ C2 s5 q' H/ i3 b! z. u$ \
18. #include <NXOpen/Selection.hxx>
    3 D, ~% v$ b. L
19. #include <NXOpen/Session.hxx>
    
20. #include <NXOpen/UI.hxx>
    , t! S* W& O" \7 p
21. #include <NXOpen/View.hxx>
    
22. 
    2 F+ Q+ J' w) d5 ~7 _
23. #include <iostream>
    8 b% E% {, Q. P3 [( j+ |* q
24. #include <sstream>
    
25. #include <list>
    + {8 B: @8 `* e7 `
26. 
    
27. using namespace NXOpen;
    
28. using namespace NXOpen::Annotations;
    
29. using namespace std;
    / V- o9 H- {( U; d/ ^  u5 r2 M4 X
30. 
    % J4 v; y0 p6 @# k  q! J, m- ?
31. class Gtac
    ; j6 k. K3 R% l" j- \4 C
32. {
    
33.     // class members
    
34. public:
    , c/ b  P: u* ?, V
35.     static Session *theSession;
    
36.     static UI *theUI;
    
37. 
    5 {: F* Y. F: U5 q/ I8 z
38.     Gtac();
    $ J: ?# \+ ^3 \  f' w& f
39.     ~Gtac();
    
40. 
    
41.     void do_it();
    
42. 
    
43. private:
    
44.     Part *workPart, *displayPart;
    6 \2 L; N/ ~. q0 Q  r( E4 o
45.     Selection *sm;
    
46.     NXMessageBox *mb;
      C* i, U, k$ L3 R: ]* i
47.     ListingWindow *lw;
    ; B: f1 v$ |; R" G
48. 
    ; B  t" ^: g8 `* X8 ~$ a
49.     Face* select_a_face();
    
50. 
    ( d4 r, }- ?1 Y  j
51. };
    : e: E+ I* a! E) W* |1 }
52. 
    9 z2 G$ I" b8 j7 }) H
53. //------------------------------------------------------------------------------
    5 y8 @# U/ |  u, p8 Q
54. // Initialize static variables
    
55. //------------------------------------------------------------------------------
    
56. Session *(Gtac::theSession) = NULL;
    4 m0 v$ L" n# B' C8 `) V
57. UI *(Gtac::theUI) = NULL;
    
58. 
    : X. B  g4 C6 @* z4 k2 z
59. //------------------------------------------------------------------------------
    : K6 Q% b4 L! V* Z% i9 i* L
60. // Declaration of global variables
    
61. //------------------------------------------------------------------------------
    
62. Gtac *theGtac;
    8 ~7 q- D, F  @+ W, `
63. 
    , s) ^5 u) Y5 A) ?3 x
64. //------------------------------------------------------------------------------
    0 i" q3 v# h- A/ R& J: G  R
65. // Constructor
    
66. //------------------------------------------------------------------------------
    1 t% D# f) o! U2 V) k% E
67. Gtac::Gtac()
    
68. {
    5 [7 _5 S0 P; F  d4 o; e
69.     // Initialize the NX Open C++ API environment
    
70.     Gtac::theSession = NXOpen::Session::GetSession();
    / H' F8 c! p, @/ H) w4 ]
71.     Gtac::theUI = UI::GetUI();
    . X9 P6 E# t9 W3 G
72. 
    & N1 r4 q; u9 h$ s9 Q  M) V
73.     sm = theUI->SelectionManager();
    
74.     mb = theUI->NXMessageBox();
    ; }4 I' B; q. d7 a+ K; ^! u  m7 n
75.     lw = theSession->ListingWindow();
    
76. 
    
77.     workPart = 0;
    
78.     displayPart = 0;
    
79. }
    
80. 
    # k4 t) a9 l& Q, V
81. //------------------------------------------------------------------------------
    
82. // Destructor
    : u1 J. q4 ^* h' G- X4 M1 M/ k
83. //------------------------------------------------------------------------------
    5 b( T8 {4 B6 l) `
84. Gtac::~Gtac()
    
85. {
    
86. }
    " v; D4 J3 _* \, l
87. 
    
88. //------------------------------------------------------------------------------
      E  W6 C7 k) E* o* l
89. // Selection
    
90. //------------------------------------------------------------------------------
    
91. Face* Gtac::select_a_face()
    
92. {
    7 v( e9 G- m: k* t+ \5 P
93.     // ask user to select a face
    
94.     UI *ui = UI::GetUI();
    " A3 C% ~: O0 V: k
95.     Selection *sm = ui->SelectionManager();
    
96.     NXMessageBox *mb = ui->NXMessageBox(); // as of NX5
    
97. 
    ' _8 O* c+ q  t+ a. y: s
98.     NXString message("Select Face:");
    
99.     NXString title("Select Face");
    
100.     Selection::SelectionScope scope = Selection::SelectionScopeUseDefault;
     ; [- m4 R) @# j0 K) m  Q( |$ O  f
101.     Selection::SelectionAction action = Selection::SelectionActionClearAndEnableSpecific;
     ( z: N" x* h, A3 g: b
102.     bool include_features = 0;
     ) s6 m' U* {! r) K/ w" C$ C5 I
103.     bool keep_highlighted = 0;
     : A$ r! t6 d" n1 S
104. 
     
105.     // Define the mask triple(s)
     4 {  p9 c6 {+ D  t
106.     std::vector<Selection::MaskTriple> mask(1);
     
107.     mask[0] = Selection::MaskTriple( UF_solid_type, 0, UF_UI_SEL_FEATURE_ANY_FACE  );
     : X! b9 S& Z7 H- C: l+ n
108.     Point3d cursor;
     
109.     NXObject *object;
     
110. 
     , k5 p. P( w/ a7 f  i1 \
111.     // Select objects using filter defined by mask triples
     
112.     Selection::Response res = sm->SelectObject(
     
113.         message, title, scope, action, include_features,
     
114.             keep_highlighted, mask, &object, &cursor );
     
115. 
     
116.     if( res == Selection::ResponseObjectSelected )
     4 D  d0 |4 ?' b. H
117.     {
     - n+ M0 Q$ n  [; z( I2 K& U6 L
118.         Face *aFace;
     
119.         aFace = (Face *)(object);
     
120.         return aFace;
     
121.     }
     # J8 x( S) c+ U5 E" z0 U6 F
122. 
     3 j- Y1 f6 D6 K8 Z
123.     return 0;
     7 p4 {6 \$ e7 C- U( }
124. }
     
125. 
     7 T# K" _& f- h% w. Z* p2 c
126. //------------------------------------------------------------------------------
     
127. // start with our job...
     2 Z" D- x: A! Z# K6 ~) u. I
128. //------------------------------------------------------------------------------
     ' g5 x5 A) c2 n6 |7 F% P& g
129. void Gtac::do_it()
     + m# N" S; a3 P( Y& ^4 M, E
130. {
     
131.     workPart = theSession->Parts()->Work();
     2 ?6 V. O  n$ X& C$ r; H
132.     Part *displayPart = theSession->Parts()->Display();
     2 ^' X! Q8 o, w- t/ D
133.     stringstream out;
     
134. 
     6 `1 L, Q3 ]+ f8 U) W: K
135.     Face *theFace = 0;
     
136.     std::list<Face*> myfaces;
     
137.    
     & i! J- k0 _; L! V, g
138.     while( (theFace=select_a_face()) != 0 )
     ; y9 _, z: w5 |; {) Z7 I& h
139.     {
     ' e; @  h0 w5 |6 _% y
140.         if(! lw->IsOpen() ) lw->Open();
     ; n- |1 H& D% d5 b
141. 
     / |7 z3 ^" a" i5 q! H
142.         out << "Selected Object: " << theFace->Tag() << endl;
     3 k  o" H6 x- t! A: G+ u
143.         lw->WriteLine(out.str().c_str());
     
144. 
     
145.         std::vector<Edge*> edges = theFace->GetEdges();
     
146.         out.str(""); out.clear();
     . F9 |' y7 ~+ o
147.         out << " Number of edges: " << edges.size() << endl;
     # f8 z2 |0 D0 R! D2 K
148.         lw->WriteLine(out.str().c_str());
     * T% N5 o, t/ s7 ]6 @5 W
149. 
     
150.         for( int ii = 0; ii < edges.size(); ii++)
     7 ^- x, O9 |3 T4 e5 G
151.         {
     
152.             out.str(""); out.clear();
     + D* B; x- ]- F/ n' [4 M) g
153.             out << " Edge: " << edges[ii]->Tag() << endl;
     , c& G" r3 A/ U* l5 B. Y
154.             lw->WriteLine(out.str().c_str());
     
155. 
       t  |" G/ H* P/ J2 c& ?0 Z8 Y6 z
156.             std::vector< NXOpen::Face * > adj_faces = edges[ii]->GetFaces();
     " @, s2 {- {! W. x
157.             out.str(""); out.clear();
     
158.             out << " Number of adjacent faces: " << adj_faces.size() << endl;
     
159.             lw->WriteLine(out.str().c_str());
     
160. 
     * X) {4 I' t$ Y1 r
161.             for( int jj = 0; jj < adj_faces.size(); jj++)
     
162.             {
       `; `5 N7 q2 S$ s( w0 m
163.                 out.str(""); out.clear();
     
164.                 out << " Adjacent face: " << adj_faces[jj]->Tag() << endl;
     
165.                 lw->WriteLine(out.str().c_str());
     
166. 
     # `% L0 Z( X+ K8 E* B+ D
167.                 myfaces.push_back(adj_faces[jj]);
     
168. 
     2 I1 e0 R6 {* l. B: c$ t7 Q3 m
169.             } // jj
     $ _9 v" H  V1 z/ D' E( f/ h
170. 
     
171.         } // ii
     & H5 {' _0 L3 ^% F# Q3 _
172. 
     / ]( d( R( D2 }/ D
173.         myfaces.unique();
     5 ~8 Z7 [! s# I2 D$ F( L
174.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     ( z$ G7 u5 u( q- h% ~. @  M7 Y
175.         {
     
176.             (*it)->Highlight();
     
177.         }
     # q4 I  R. N# k
178.         Gtac::theUI->NXMessageBox()->Show("Adjacent Faces", NXOpen::NXMessageBox::DialogTypeInformation, "Confirm");
     5 Q7 B7 u6 l: w& ~4 t
179.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     
180.         {
     
181.             (*it)->Unhighlight();
     ) |# Y- z7 s; U2 v1 x( {' k, }, e# w
182.         }
     
183.         myfaces.clear();
     
184. 
     
185. 
     
186.     } // while
     0 k& `: U  i2 R4 D6 h/ j3 Z
187. }
     3 H" I1 x+ b3 z( l! J$ t0 d& T
188. 
     
189. //------------------------------------------------------------------------------
     
190. // Entry point for our unmanaged internal C++ program
     
191. //------------------------------------------------------------------------------
     ( M" i& E  Y& ^! t
192. extern DllExport void ufusr( char *parm, int *returnCode, int rlen )
     0 W5 m( D7 q+ {6 e2 Q1 @6 P+ p
193. {
     2 E9 g" d& F. y. L2 f- I6 |/ N( T
194.     try
     
195.     {
     % B7 y  `$ ~/ [- R+ W% o
196.         theGtac = new Gtac();
     % n8 a  h# |1 t' c, n
197.         theGtac->do_it();
     - B" c3 ~+ {# w0 w
198.         delete theGtac;
     ' Q  _# ^$ w. G' z2 Q' V4 J* L+ Q
199.     }
     & X, n1 @" |( V3 T% O4 M
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());
     7 R9 q% @& t1 X' \$ q" r( \- ~
204.     }
     
205. }
     . l5 L+ w: Y7 |* l9 q3 A
206. 
     
207. 
     
208. //------------------------------------------------------------------------------
     $ g5 \7 `# V( n
209. // Unload Handler
     
210. //------------------------------------------------------------------------------
     
211. extern "C" DllExport int ufusr_ask_unload()
     0 H8 m5 g. `2 ]' A7 I; k4 d) I
212. {
     
213. return (int)NXOpen::Session::LibraryUnloadOptionImmediately;
       P7 d* B4 |& _) B8 Q' c
214. }
     - X4 q7 S% F* v1 q% D
215. 
     2 M4 N. o8 p5 j% v( m7 A& H" r

复制代码