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

admin

通过这个代码，可以获取选择面的相邻面的信息
NX open C++中使用了 选择对象 selectobject 函数，通过面获取边数据，通过边获取面，从而得到信息！
0 I  I5 ]! e" Z7 L% K9 l: b

1. #include <uf.h>
   
2. #include <uf_ui.h>
   ' h5 `+ ]& T# x* q4 j) I
3. #include <uf_object_types.h>
   / h0 B. m  f7 x' H# G$ A
4. 
   ( Q) \: e- o& L
5. #include <NXOpen/Edge.hxx>
   - U6 W7 ?! x; g, }2 A5 O
6. #include <NXOpen/Face.hxx>
     K6 p4 D# k6 J+ w5 w! g
7. 
   6 G3 t% D- ~: p' n+ |9 Q
8. #include <NXOpen/ListingWindow.hxx>
   & g3 r* U# B, @3 _$ k( U
9. #include <NXOpen/NXException.hxx>
   & @. ~, d3 n1 S9 E7 z& U- i: `8 j1 I
10. #include <NXOpen/NXMessageBox.hxx>
    ! H. f; K% L' N, [3 ]
11. #include <NXOpen/NXObject.hxx>
    , Q8 v! J: V8 n2 A
12. #include <NXOpen/Part.hxx>
    
13. #include <NXOpen/ParTCollection.hxx>
    3 q# l3 G5 D" t5 n7 K
14. #include <NXOpen/SelectDisplayableObject.hxx>
    
15. #include <NXOpen/SelectDisplayableObjectList.hxx>
    & y8 H: [- p) F' _1 F
16. #include <NXOpen/SelectObject.hxx>
    
17. #include <NXOpen/SelectObjectList.hxx>
    ' _. x8 {" T+ ~" _
18. #include <NXOpen/Selection.hxx>
    
19. #include <NXOpen/Session.hxx>
    ( w7 X. T% r1 f* `+ d
20. #include <NXOpen/UI.hxx>
    
21. #include <NXOpen/View.hxx>
    ) V( K" H; G8 D! d
22. 
    ! S& o8 e& L* }" a' \; h
23. #include <iostream>
    + K: S8 Q0 @- Q( `
24. #include <sstream>
    
25. #include <list>
    
26. 
    
27. using namespace NXOpen;
    3 U) q5 F& Y3 Z9 ~
28. using namespace NXOpen::Annotations;
    
29. using namespace std;
    % W8 c% F  p# `, N" k
30. 
    
31. class Gtac
    
32. {
    6 g% P+ }: h( |% M2 F( ~/ t( U% w0 v
33.     // class members
    : }; p  A3 E; }1 ^" g
34. public:
    
35.     static Session *theSession;
      l  m& D3 l- N2 n8 i
36.     static UI *theUI;
    
37. 
    
38.     Gtac();
    # y" l  U* k" I0 ^: F' ~
39.     ~Gtac();
    
40. 
    % e! @0 ^7 l& q! [* s' b$ _% b
41.     void do_it();
    : y, M9 b+ ?5 z
42. 
    0 @; d$ B7 }3 B
43. private:
    
44.     Part *workPart, *displayPart;
    " i# v2 u2 m9 Q5 m
45.     Selection *sm;
    8 i/ ^, Y6 c* m% v+ d" C
46.     NXMessageBox *mb;
    # `: @2 A  w$ l$ c3 _: p5 e. R2 B
47.     ListingWindow *lw;
    # b; N( f8 O7 u9 ~  {
48. 
    # I9 k* H0 y* T' x" [
49.     Face* select_a_face();
    
50. 
    
51. };
    % S* W) w0 W4 q; Q  c
52. 
    
53. //------------------------------------------------------------------------------
    
54. // Initialize static variables
    4 B$ x: S( c- t& {
55. //------------------------------------------------------------------------------
    
56. Session *(Gtac::theSession) = NULL;
    
57. UI *(Gtac::theUI) = NULL;
    ; n6 M! I! \3 ]. x
58. 
    
59. //------------------------------------------------------------------------------
    + ~" t/ q' J- N6 d. w$ v7 q) Y' Z5 ]6 T
60. // Declaration of global variables
    & h- ]& s) G; f9 F# @
61. //------------------------------------------------------------------------------
    
62. Gtac *theGtac;
    
63. 
    * @; E( y6 v  ^6 w$ Y( W
64. //------------------------------------------------------------------------------
    ! Z% `8 y9 G. r& A, b: X% q- q( D4 Z
65. // Constructor
    
66. //------------------------------------------------------------------------------
    + h% U* k$ |2 {& q
67. Gtac::Gtac()
    ' a6 ^6 p, Q6 @$ z
68. {
    
69.     // Initialize the NX Open C++ API environment
    ' M) h* C# b( A, b1 [
70.     Gtac::theSession = NXOpen::Session::GetSession();
    
71.     Gtac::theUI = UI::GetUI();
    ( R7 B0 A8 b8 G) N
72. 
    7 |# ^, D, L  b9 z3 D2 ?; p& L
73.     sm = theUI->SelectionManager();
    
74.     mb = theUI->NXMessageBox();
    
75.     lw = theSession->ListingWindow();
    , k( t5 D! \5 e" H. j% T! A
76. 
    
77.     workPart = 0;
    
78.     displayPart = 0;
    1 z* b+ d# k. S* B. ]
79. }
    
80. 
    
81. //------------------------------------------------------------------------------
    
82. // Destructor
    
83. //------------------------------------------------------------------------------
    * q* H: o6 c# k  W4 e' T
84. Gtac::~Gtac()
    
85. {
    
86. }
    $ s* ^3 J! E( {1 M
87. 
    9 E* ^  J+ O+ S) z/ |: {
88. //------------------------------------------------------------------------------
    8 ^$ p, n3 d2 }) [9 N; H
89. // Selection
    - s, }6 V  C2 @  w) i6 d( d# |' s8 a
90. //------------------------------------------------------------------------------
    . e! p2 y$ v  c& p& B6 q
91. Face* Gtac::select_a_face()
      a! x) D- p' _6 u4 l
92. {
    & B/ Y. \, _# `8 z' P; U
93.     // ask user to select a face
    
94.     UI *ui = UI::GetUI();
    0 h% k+ j  D( z9 {# x
95.     Selection *sm = ui->SelectionManager();
    3 j% i0 }: n& ?4 r9 {. D( }
96.     NXMessageBox *mb = ui->NXMessageBox(); // as of NX5
    ; v3 a* B# U1 o3 V  A
97. 
    
98.     NXString message("Select Face:");
    & \2 o1 w8 T% A! D3 Q! J
99.     NXString title("Select Face");
    
100.     Selection::SelectionScope scope = Selection::SelectionScopeUseDefault;
     : P9 ]$ M1 T% M3 n. A
101.     Selection::SelectionAction action = Selection::SelectionActionClearAndEnableSpecific;
     
102.     bool include_features = 0;
     
103.     bool keep_highlighted = 0;
     $ M4 y& w2 C1 L3 {% E# W3 A
104. 
     
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  );
     8 I( a8 d2 \3 k2 c0 M. }
108.     Point3d cursor;
     $ u# A& x( s7 m
109.     NXObject *object;
     
110. 
     
111.     // Select objects using filter defined by mask triples
     
112.     Selection::Response res = sm->SelectObject(
     / F7 y  P& a- L! T$ ]
113.         message, title, scope, action, include_features,
     ; n7 w' O8 q- n5 I( B
114.             keep_highlighted, mask, &object, &cursor );
     ' P/ E3 w" d5 v5 k" |# E5 g$ O
115. 
     8 t! U% q4 H. k# \( T
116.     if( res == Selection::ResponseObjectSelected )
     $ c7 x" v  W% P, k( a0 u) T8 c
117.     {
     
118.         Face *aFace;
     $ O/ n7 o# h# w) [9 W2 M  @$ x
119.         aFace = (Face *)(object);
     # K8 c: O) \% [4 y) }
120.         return aFace;
     
121.     }
     
122. 
     
123.     return 0;
     6 T# q# s9 e0 v7 P3 o8 I1 ?/ B* E
124. }
     : A2 z1 C8 G2 f$ a8 q2 o! e
125. 
     
126. //------------------------------------------------------------------------------
     
127. // start with our job...
     1 O" _  g  k, i4 k) x  H; d
128. //------------------------------------------------------------------------------
     1 v9 A( v8 {/ z, S+ w7 m
129. void Gtac::do_it()
     * j+ w2 a* q8 ^! s- f
130. {
       }$ G* u/ ^% y1 _
131.     workPart = theSession->Parts()->Work();
     * J+ E& ]" Z/ x, Z' Y* L
132.     Part *displayPart = theSession->Parts()->Display();
     5 u& C8 Y3 x* ]: q/ g" O
133.     stringstream out;
     - F- B. i1 e. q7 r
134. 
     
135.     Face *theFace = 0;
     - z2 B2 U' Y, Q5 u
136.     std::list<Face*> myfaces;
     
137.    
     
138.     while( (theFace=select_a_face()) != 0 )
     , ]* S2 C1 t* L7 |* B
139.     {
     
140.         if(! lw->IsOpen() ) lw->Open();
     
141. 
     
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();
     6 g! Q) R; O- ]
147.         out << " Number of edges: " << edges.size() << endl;
     
148.         lw->WriteLine(out.str().c_str());
     
149. 
     0 [  I2 o; ]; O; a
150.         for( int ii = 0; ii < edges.size(); ii++)
     . @* h% k! `" }- b
151.         {
     
152.             out.str(""); out.clear();
     # ~. V9 T$ a8 s' [( l+ W
153.             out << " Edge: " << edges[ii]->Tag() << endl;
     + O4 l/ k* |7 V5 Y: ^* ]: F& F1 B( I
154.             lw->WriteLine(out.str().c_str());
     1 B' E( Y  k  u" |' d. d
155. 
     , X0 s' P$ Z7 F$ ^. `/ T$ v7 }: o" i
156.             std::vector< NXOpen::Face * > adj_faces = edges[ii]->GetFaces();
     
157.             out.str(""); out.clear();
     0 D. H0 |8 w+ z5 l9 O
158.             out << " Number of adjacent faces: " << adj_faces.size() << endl;
     
159.             lw->WriteLine(out.str().c_str());
     
160. 
     $ P# M, c7 v: [9 |
161.             for( int jj = 0; jj < adj_faces.size(); jj++)
     
162.             {
     
163.                 out.str(""); out.clear();
     ' a+ W9 G( k/ x5 g
164.                 out << " Adjacent face: " << adj_faces[jj]->Tag() << endl;
     ( {; g! j7 T+ _$ O7 q. N+ y2 c
165.                 lw->WriteLine(out.str().c_str());
     
166. 
     
167.                 myfaces.push_back(adj_faces[jj]);
     
168. 
     1 X0 i8 X2 K4 c5 L
169.             } // jj
     
170. 
     
171.         } // ii
     
172. 
     0 u) A5 U" _* l4 X9 k% N1 {
173.         myfaces.unique();
     
174.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     
175.         {
     ' X* {1 V* n% `- b: U% }
176.             (*it)->Highlight();
     & k0 y0 L* j1 m+ U" t" A' [
177.         }
     8 o! {0 ]7 ~4 l& O6 `
178.         Gtac::theUI->NXMessageBox()->Show("Adjacent Faces", NXOpen::NXMessageBox::DialogTypeInformation, "Confirm");
     & l, ?7 G  ?8 u3 B* T+ _: g
179.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     ( e! H, Z3 E9 i( u. [' f
180.         {
     / c/ H" x- ^6 j) J
181.             (*it)->Unhighlight();
     
182.         }
     4 ~2 s, s$ h& k1 J7 i
183.         myfaces.clear();
     
184. 
     - ?; o) F  _, m+ N2 {2 D4 N
185. 
     
186.     } // while
     
187. }
     - \  D/ ^1 \; E2 q- D
188. 
     
189. //------------------------------------------------------------------------------
     * j- r! E" o+ ~6 b4 }; t
190. // Entry point for our unmanaged internal C++ program
     1 j. x, q8 S# d2 i& I4 @, d) I7 E
191. //------------------------------------------------------------------------------
     
192. extern DllExport void ufusr( char *parm, int *returnCode, int rlen )
     % b3 \8 s9 i  S1 T2 N7 O/ @; Q! k7 X# O
193. {
     - a  \3 X7 I' P6 D: Z3 T( k
194.     try
     6 M* }9 V% k  B% @6 j
195.     {
     
196.         theGtac = new Gtac();
     & V6 S/ ]3 Q/ a; T
197.         theGtac->do_it();
     : ?+ T  Q8 c6 N, r5 O) n) Z
198.         delete theGtac;
     9 ]1 u5 t0 w% Z/ N; f# D& a$ k0 R; B5 u
199.     }
     
200.     catch (const NXOpen::NXException& ex)
     ; U; _) `3 ?/ F
201.     {
     ' e5 G& b$ w) m  R2 k
202.         // ---- Enter your exception handling code here -----
     $ o! N3 q6 B6 T  d
203.         Gtac::theUI->NXMessageBox()->Show("CaUGht Error", NXOpen::NXMessageBox::DialogTypeError, ex.Message());
     
204.     }
     
205. }
     
206. 
     6 G5 e. X) F0 ?6 o. L! m4 I
207. 
     
208. //------------------------------------------------------------------------------
     
209. // Unload Handler
     
210. //------------------------------------------------------------------------------
     - K6 L" P' M6 H& Q* w% f9 u  |2 Q
211. extern "C" DllExport int ufusr_ask_unload()
     
212. {
     
213. return (int)NXOpen::Session::LibraryUnloadOptionImmediately;
     6 i# K7 f& g- I) o9 f) U
214. }
     
215. 
     

复制代码