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

admin

通过这个代码，可以获取选择面的相邻面的信息
NX open C++中使用了 选择对象 selectobject 函数，通过面获取边数据，通过边获取面，从而得到信息！
4 E$ I  b2 a6 z9 M
/ o$ r& B+ c3 h( D: G

1. #include <uf.h>
   8 E! b/ S2 t( E) G& W" f3 a0 a
2. #include <uf_ui.h>
   
3. #include <uf_object_types.h>
   
4. 
   % a; \7 {" ^+ V8 c4 q
5. #include <NXOpen/Edge.hxx>
   
6. #include <NXOpen/Face.hxx>
   
7. 
   
8. #include <NXOpen/ListingWindow.hxx>
   ; a& s- z. q( t0 `5 E, N, a; a
9. #include <NXOpen/NXException.hxx>
   3 V3 {0 o8 a- ^; w$ D; P, y
10. #include <NXOpen/NXMessageBox.hxx>
    
11. #include <NXOpen/NXObject.hxx>
    
12. #include <NXOpen/Part.hxx>
    
13. #include <NXOpen/ParTCollection.hxx>
    & C4 @* N- d" a! y: l) d
14. #include <NXOpen/SelectDisplayableObject.hxx>
    ' m! m6 @* z" B+ ~' E
15. #include <NXOpen/SelectDisplayableObjectList.hxx>
    ( U: O7 }) C  T% {" d
16. #include <NXOpen/SelectObject.hxx>
    
17. #include <NXOpen/SelectObjectList.hxx>
    
18. #include <NXOpen/Selection.hxx>
    
19. #include <NXOpen/Session.hxx>
      k" R' U$ ]; d# s3 `, `3 s
20. #include <NXOpen/UI.hxx>
    
21. #include <NXOpen/View.hxx>
    
22. 
    & M# b5 Z" O/ w
23. #include <iostream>
    
24. #include <sstream>
    + C5 p: z  w# J' O
25. #include <list>
    
26. 
    
27. using namespace NXOpen;
    % [6 V, Q" M5 k1 u+ J5 L9 @
28. using namespace NXOpen::Annotations;
    
29. using namespace std;
    - a8 x& [( f7 _& a5 `; @6 V
30. 
    
31. class Gtac
    & y8 ]$ G! n+ z4 c  \% A2 I+ I3 o
32. {
    : x3 F' b+ x' {$ N6 s
33.     // class members
    5 a. T  D# z( f' J5 o/ w
34. public:
    ! e% [# X1 O' L) U/ X; ^, M0 K
35.     static Session *theSession;
    ( A& D2 C% V8 v
36.     static UI *theUI;
    + m: O7 p: k( s' H
37. 
    
38.     Gtac();
    $ {) x2 v$ X; y7 w* f  I5 i- E0 z
39.     ~Gtac();
    - ?6 E; A( o& K( @0 C
40. 
    6 ]3 W6 x% p; w& q
41.     void do_it();
    
42. 
    
43. private:
      u# t3 }4 m3 ]
44.     Part *workPart, *displayPart;
    8 j4 h& o9 r- N$ D1 ]
45.     Selection *sm;
    , p9 b) a$ ?* ?
46.     NXMessageBox *mb;
    & w. f/ w' W7 I
47.     ListingWindow *lw;
    ' p7 \. ?! q/ \1 n7 ^
48. 
    3 Y$ M  U& R2 H
49.     Face* select_a_face();
    
50. 
    " U) O( l1 j! b& v  j
51. };
    . a2 ]% c$ B; G$ ]! z: z
52. 
    , Y/ d8 }9 G- B4 I2 z
53. //------------------------------------------------------------------------------
    : Y' |: V0 B  k
54. // Initialize static variables
    2 C0 w* O$ ^8 o1 X
55. //------------------------------------------------------------------------------
    
56. Session *(Gtac::theSession) = NULL;
    
57. UI *(Gtac::theUI) = NULL;
    
58. 
    
59. //------------------------------------------------------------------------------
    
60. // Declaration of global variables
    
61. //------------------------------------------------------------------------------
    
62. Gtac *theGtac;
    
63. 
    " T2 j7 p! v! B2 @- K# F2 x# Y
64. //------------------------------------------------------------------------------
    " m+ O/ `. f- Q, k5 O
65. // Constructor
    
66. //------------------------------------------------------------------------------
    
67. Gtac::Gtac()
    
68. {
    
69.     // Initialize the NX Open C++ API environment
    
70.     Gtac::theSession = NXOpen::Session::GetSession();
    2 R' x& @  V# F# g$ J. o
71.     Gtac::theUI = UI::GetUI();
    
72. 
    
73.     sm = theUI->SelectionManager();
    8 ^; ~# b$ E1 W9 b+ O
74.     mb = theUI->NXMessageBox();
    
75.     lw = theSession->ListingWindow();
    
76. 
    
77.     workPart = 0;
    ) I3 o2 w  x# x. F7 B4 V4 b1 ^/ L
78.     displayPart = 0;
    
79. }
    5 a8 d9 X; R+ b0 u* ?
80. 
      M/ J0 l: Y9 {" C2 k
81. //------------------------------------------------------------------------------
    
82. // Destructor
    
83. //------------------------------------------------------------------------------
    
84. Gtac::~Gtac()
    6 f! X8 X% y% G0 b  S) }* A9 x
85. {
    ' c4 B6 l& d, Z* ?# W; t
86. }
    / Z) c" H+ Y7 H8 h8 }7 X/ P
87. 
    ) U  l) i% N4 t( ~7 k5 a
88. //------------------------------------------------------------------------------
    
89. // Selection
    ; @9 P) N2 Z5 |: z
90. //------------------------------------------------------------------------------
    ' h( Z# e. o* _+ ]+ [5 }
91. Face* Gtac::select_a_face()
    
92. {
      \; E8 X' b% }# e' s& p) R
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
    - G+ `5 X, n4 ~" v. r" c+ {. M
97. 
    * Y# r# m- \* \# q' v& A: M
98.     NXString message("Select Face:");
    0 M3 V2 L/ R& g. O
99.     NXString title("Select Face");
    
100.     Selection::SelectionScope scope = Selection::SelectionScopeUseDefault;
     
101.     Selection::SelectionAction action = Selection::SelectionActionClearAndEnableSpecific;
     ; t' S1 }( w+ f( \3 ^
102.     bool include_features = 0;
     % L+ r2 a5 I' z: B5 c8 ]0 Y; L
103.     bool keep_highlighted = 0;
     + N3 E! U0 V/ @# w
104. 
     
105.     // Define the mask triple(s)
     ! i: o( L7 t& Q5 ]% ^9 z
106.     std::vector<Selection::MaskTriple> mask(1);
     
107.     mask[0] = Selection::MaskTriple( UF_solid_type, 0, UF_UI_SEL_FEATURE_ANY_FACE  );
     1 k' b0 q5 x7 \" E6 G
108.     Point3d cursor;
     : U) X9 C6 q" G3 {2 s3 t
109.     NXObject *object;
     : g% q! K$ d1 i- E: \
110. 
     6 T' X" E& w4 n  b. S7 k; u) l
111.     // Select objects using filter defined by mask triples
     . G2 `1 I9 ]8 k6 r: A4 b- M
112.     Selection::Response res = sm->SelectObject(
     
113.         message, title, scope, action, include_features,
     - F  L3 M4 v7 ~' H3 u* ]+ o
114.             keep_highlighted, mask, &object, &cursor );
     $ R6 p7 M7 ?2 T! l% B  Q
115. 
     
116.     if( res == Selection::ResponseObjectSelected )
     3 B0 w" K2 w  y7 P
117.     {
     5 [, g7 P2 B: M, }% X
118.         Face *aFace;
     ; A- x) m4 `( W4 T: T$ D* T9 F# ~
119.         aFace = (Face *)(object);
     
120.         return aFace;
     " {( T$ x4 Y* e1 ]4 A& P
121.     }
       c- M+ |2 b! L9 k4 S; P
122. 
     / t2 T. }5 a4 t  r. N: W6 V
123.     return 0;
     
124. }
     
125. 
     
126. //------------------------------------------------------------------------------
     * X$ X0 N* ^3 j/ s/ L- [
127. // start with our job...
     
128. //------------------------------------------------------------------------------
     ) w* _; {3 B) I  i% M3 ?1 r/ j1 F
129. void Gtac::do_it()
     
130. {
     ( z1 {4 o: G' |8 A6 V. m# ^
131.     workPart = theSession->Parts()->Work();
     
132.     Part *displayPart = theSession->Parts()->Display();
     
133.     stringstream out;
     : b* Q, `7 J' q
134. 
     . G+ Q3 H' T4 i: ?1 f# g
135.     Face *theFace = 0;
     
136.     std::list<Face*> myfaces;
     7 M  C5 ^7 O: n+ {6 c
137.    
     ( X; F7 i, @1 h# V7 K
138.     while( (theFace=select_a_face()) != 0 )
     ! ?/ B+ V5 d7 x' I) ?
139.     {
     4 ], T0 X" w: ]) J6 A( j3 ~
140.         if(! lw->IsOpen() ) lw->Open();
     . h% E# z/ k0 S" i' I
141. 
     : O$ H0 G/ Y4 w* N  l( ~
142.         out << "Selected Object: " << theFace->Tag() << endl;
     # Z9 R# o; E& U9 l* K8 d2 }  _6 S
143.         lw->WriteLine(out.str().c_str());
     
144. 
     " \4 G: e- D" M. ?7 T
145.         std::vector<Edge*> edges = theFace->GetEdges();
     3 f* G" ]6 O; d7 M1 H$ d
146.         out.str(""); out.clear();
     
147.         out << " Number of edges: " << edges.size() << endl;
     
148.         lw->WriteLine(out.str().c_str());
     
149. 
     / a6 V( k# \; ^* L% d7 m
150.         for( int ii = 0; ii < edges.size(); ii++)
     
151.         {
     ( M. Q( S9 Z, j  l8 |) T+ [, W4 B
152.             out.str(""); out.clear();
     9 [- k5 \* }9 E7 `
153.             out << " Edge: " << edges[ii]->Tag() << endl;
     
154.             lw->WriteLine(out.str().c_str());
     ! q$ y: f9 Z7 P: {
155. 
     
156.             std::vector< NXOpen::Face * > adj_faces = edges[ii]->GetFaces();
     % j* D+ j/ L- v
157.             out.str(""); out.clear();
     
158.             out << " Number of adjacent faces: " << adj_faces.size() << endl;
     3 s8 o* _* K( i( G- ~0 \) l
159.             lw->WriteLine(out.str().c_str());
     " F( l. o7 G2 k
160. 
     & x' F6 c" L1 l& g2 N! q. m
161.             for( int jj = 0; jj < adj_faces.size(); jj++)
     0 p6 C+ z6 G6 G6 z
162.             {
     ; Y' J. F: W7 O
163.                 out.str(""); out.clear();
     
164.                 out << " Adjacent face: " << adj_faces[jj]->Tag() << endl;
       B' r. F* L) k; K2 m6 {
165.                 lw->WriteLine(out.str().c_str());
     
166. 
     ( i8 S: O! }/ w" r$ V8 }# ]
167.                 myfaces.push_back(adj_faces[jj]);
     ! f1 Y0 ^) i' {- p. ~: J
168. 
     
169.             } // jj
     
170. 
     4 Y0 u4 R' {' B# W; }2 f
171.         } // ii
     5 K) M' V7 Y; W0 x! X
172. 
     / u% q( H' J. L/ N
173.         myfaces.unique();
     
174.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     6 Y1 P; G% |- K( C7 a4 K
175.         {
     ; f/ W' h6 O2 J
176.             (*it)->Highlight();
       Y3 {. Q- @' t0 R" F$ j7 L
177.         }
     , R4 d  j7 o  a' J0 a$ M: T
178.         Gtac::theUI->NXMessageBox()->Show("Adjacent Faces", NXOpen::NXMessageBox::DialogTypeInformation, "Confirm");
     
179.         for (list<Face*>::iterator it=myfaces.begin(); it!=myfaces.end(); ++it)
     
180.         {
     
181.             (*it)->Unhighlight();
     8 Q. D7 J1 g& n( n0 N
182.         }
     
183.         myfaces.clear();
     
184. 
     
185. 
     
186.     } // while
     7 u0 m  i% M8 E6 m2 t
187. }
     - c3 S' `9 d4 e. N
188. 
     - g5 i7 m& C1 K3 C
189. //------------------------------------------------------------------------------
     4 H! g/ @" v3 {  e4 ?4 {8 {" z
190. // Entry point for our unmanaged internal C++ program
     ' H* m/ |4 d. w% S6 D) E% \* k
191. //------------------------------------------------------------------------------
     
192. extern DllExport void ufusr( char *parm, int *returnCode, int rlen )
     - `6 e3 Y4 U+ k* I  ]' H% i& z
193. {
     4 c4 U; E! |; _9 T
194.     try
     4 x; L. F* \/ o" a5 U
195.     {
     ( q9 x! c: F0 v& }0 Q
196.         theGtac = new Gtac();
     
197.         theGtac->do_it();
     , {& v" R9 X! e2 `+ ?4 b
198.         delete theGtac;
     $ |* a" \$ _& v5 i6 p- b
199.     }
     1 _" W8 h* @' q) K8 E9 s$ k
200.     catch (const NXOpen::NXException& ex)
     , y  k4 a  c& k( d
201.     {
     
202.         // ---- Enter your exception handling code here -----
     5 J3 D- J+ V2 p9 n7 V: N# A
203.         Gtac::theUI->NXMessageBox()->Show("CaUGht Error", NXOpen::NXMessageBox::DialogTypeError, ex.Message());
     
204.     }
     
205. }
     : U8 o. M4 r" l8 l' a
206. 
     
207. 
     4 ^/ _2 ]8 N. w: z
208. //------------------------------------------------------------------------------
     ; m& S! K' |& T. r$ z1 X- M- J
209. // Unload Handler
     
210. //------------------------------------------------------------------------------
     2 D5 `/ s6 ]5 Y9 L+ p, K  b
211. extern "C" DllExport int ufusr_ask_unload()
     % A: a9 w/ g0 h; e
212. {
     ; X7 P6 m# z: @+ S: X9 _
213. return (int)NXOpen::Session::LibraryUnloadOptionImmediately;
     7 Y+ r3 k6 l% _/ w' P5 Z5 w: e1 ]
214. }
     4 |4 M7 ^; E! p+ v
215. 
     & g1 A! p: H# t% q. ]% r& ]# h

复制代码