UG二次开发源码：计算曲线信息评估非常好用的方法分享

admin

( [* r8 v( _7 s3 a
7 T1 P: t3 z- ~, c$ d* \) _
! U/ h8 [* b/ T- g) i

1. /******************************************************************************
   
2.              Copyright (c) 1999 Unigraphics Solutions, Inc.
   % T- u; i& J3 J
3.                        Unpublished - All Rights Reserved
     t! \! A! `( R6 G
4. 
   
5. *******************************************************************************/
   3 D4 ]$ ]" q+ t3 W* L% v( J7 r0 Q
6. /* This example demonstrates the UF_EVAL api for lines and arcs.
   
7. Some of the UF_EVAL routines operate on an evaluator
   % ?& D2 N8 t) H4 a
8. independent of type while others are type dependent.  No longer use
   8 {/ E. j, W. ]
9. UF_CURVE_ask_curve_struct ( ),
   ; \, s& r; k7 J  b8 ]% g" }( z: q
10. UF_CURVE_ask_curve_struct_data ( ) and
    4 s! V. Y' T& f& C( }
11. UF_CURVE_free_curve_struct ( )
    
12. */
    
13. 
    
14. #include <stdio.h>
    ) }) Z2 s$ t' `) g
15. #include <uf_object_types.h>
    4 h. R6 _( |% ~8 `" v4 D
16. #include <uf_curve.h>
    7 T2 F0 L' v1 Q  U7 r8 j5 S6 D
17. #include <uf_eval.h>
    
18. #include <uf_modl.h>
    ) A3 Z( |* q9 u5 Z# i- J
19. #include <uf_part.h>
    
20. #include <uf_so.h>
    $ f7 H; q! J9 J4 I, \" `
21. #include <uf.h>
    0 f; o% D7 t& l5 ]) e! N
22. #define UF_CALL( X ) ( report ( __FILE__, __LINE__, #X, ( X ) ) )
    ! F/ E# Y+ q& |1 W
23. static void show_edge_points(UF_EVAL_p_t eval, int n_pts);
    
24. /*---------------------------------------------------------------*/
    
25. static int report ( char *file, int line, char *call, int irc )
    
26. {
    
27.     if ( irc )
    7 C3 E, P8 ^! {2 ^! s# e9 Z
28.     {
    
29.         char message [ 132 + 1 ];
      y% J6 o5 G+ m& t( \
30.         printf ( "%s, line %d:  %s\n", file, line, call );
    8 z6 ]* i4 R/ U
31.         UF_get_fail_message ( irc, message ) ?
    
32.             printf ( "    error %d\n", irc ) :
    
33.             printf ( "    error %d:  %s\n", irc, message );
    
34.     }
    
35.     return irc;
    
36. }
    
37. /*---------------------------------------------------------------*/
    
38. int ufusr_ask_unload ( void )
    " y  f; z& g# o. @$ W( j2 j  Q8 C' d' g
39. {
    
40.     return UF_UNLOAD_IMMEDIATELY;
    6 \( Y& ~0 N* j$ |! R8 x6 |
41. }
    . p) t2 V; I# I% L9 o
42. /*---------------------------------------------------------------*/
    
43. /* ARGSUSED */
    
44. extern void ufusr ( char *param, int *reTCod, int param_len )
    
45. {
    4 B5 R1 x/ u; [
46.     tag_t line;
    % R( e1 |5 Z5 N
47.     tag_t arc;
    
48.     tag_t edge;
    
49.     tag_t edges [ 3 ];
    , V" h9 @9 t, }
50.     UF_EVAL_p_t line_evaluator;
    
51.     UF_EVAL_p_t arc_evaluator;
    
52.     UF_EVAL_p_t edge_evaluator;
    
53.     UF_CALL ( UF_initialize ( ) );
    
54.     /*  
    & W' X8 H9 D7 t& v' w. w  X3 N
55.         Create new part "ufd_eval.prt".
    
56.         
    $ l6 c+ T: P- l' p# g/ Z
57.         Close part if it already exists.
    " q4 J6 _4 h( D. k' R
58.     */
    3 U+ S. z! v  y& v
59.     {
    / t. x; _$ ?. W7 V( @1 e  e
60.         tag_t part = UF_PART_ask_part_tag ( "ufd_eval.prt" );
    
61.         if ( part != NULL_TAG )
    
62.         {
    
63.             UF_CALL ( UF_PART_close ( part, 0, 1 ) );
    " S6 N, i7 D% J& B
64.         }
    
65.         UF_CALL ( UF_PART_new ( "UGd_eval.prt",
    
66.                                 UF_PART_ENGLISH,
    ' t3 ^& d  D" p5 f% B# w8 Y4 E
67.                                 &part ) );
    2 U8 B4 N4 |' e. `7 s
68.     }
    4 O/ s0 a) t9 u+ ~+ M/ o! L- {
69.     /*
    
70.         Create block and get edges.
    
71.     */
    
72.     {
    - y8 E: T4 S% a( o
73.         double  origin [ ] = { 0.0, 0.0, 0.0 };
    
74.         char   *sizes  [ ] = { "1", "1", "1" };
    
75.         tag_t block_feature;
    
76.             
    * D6 V7 n6 c4 F/ X: b
77.         UF_CALL ( UF_MODL_create_block1 ( UF_NULLSIGN,
    
78.                                           origin,
    
79.                                           sizes,
    
80.                                           &block_feature ) );
    
81.         {
    
82.             uf_list_p_t edge_list;
    
83.             UF_CALL ( UF_MODL_ask_feat_edges ( block_feature,
    9 S, z- E$ I4 ^2 G4 [
84.                                                &edge_list ) );
    8 n' m5 O# Y6 @/ O' d: e6 M
85.             
    , E$ z# C5 A7 V( i
86.             UF_CALL ( UF_MODL_ask_list_item ( edge_list,
    
87.                                               1,
    
88.                                               &edge ) );
    # a1 t$ _/ ~# U/ R3 n$ @
89.             edges [ 0 ] = edge;
    3 G: P. c: R, M) A  o' ~6 n
90.             edges [ 1 ] = edge;
    
91.             UF_CALL ( UF_MODL_ask_list_item ( edge_list,
    
92.                                               0,
    - M) D  A8 e1 v4 {0 W& t7 o9 P
93.                                               &edges [ 2 ] ) );
    1 j+ K7 C9 r: z9 Q- F
94.             UF_CALL ( UF_MODL_delete_list ( &edge_list ) );
    
95.         }
    
96. }
    
97.     /*  
    8 }# a# I" ]7 L: x0 O- E
98.         Create smart line.
    % W1 b5 _" h" _+ ?) a" ^* B2 F& p+ [
99.     */
    ! O( z% [5 n! K
100.     UF_CALL ( UF_SO_create_curve_extract
     
101.               (
     9 ~1 b2 B' {  e8 N5 [+ g
102.                   edge,
     
103.                   UF_SO_update_after_modeling,
     + L0 k! s' v; M8 C! j% t
104.                   edge,
     & C9 E& W6 c! P' l% ~
105.                   UF_line_type, /* enforce line type */
     
106.                   0,            /* no subtype to enforce */
     
107.                   NULL_TAG,
     - N! T# p0 X2 P
108.                   &line
     + T4 X- {% y/ t3 F, _
109.               ) );
     
110.         
     2 b) n$ a3 R, m/ X7 h: S3 l7 ]
111.     /*  
     ( F3 `6 ~6 F- f3 W1 q
112.         Create smart arc.
     
113.     */
     
114.     {
     
115.         int i;
     $ @6 l1 S, [' v/ c
116.         tag_t points [ 3 ];
     
117.         for ( i = 0; i < 3; i++ )
     % M% x, ?0 m( [4 _" i
118.         {
     / u$ u& ]2 Y; _9 u. W
119.             char *strings [  ] = { "center=1.0",
     , s( @5 W% S% c2 T
120.                                    "start=0.0",
     
121.                                    "end=1.0" };
     
122.             tag_t exps    [ 3 ];
     
123.             tag_t scalars [ 3 ];
     
124.             UF_CALL ( UF_MODL_create_exp_tag ( strings [ i ],
     
125.                                                &exps [ i ] ) );
     
126.             UF_CALL ( UF_SO_create_scalar_exp
     
127.                       (
     3 N. |$ P1 ^' e
128.                           exps [ i ],
     
129.                           UF_SO_update_after_modeling,
     % r, _7 K* `6 s
130.                           exps [ i ],
     ) E6 Y; [! z# K' H
131.                           &scalars [ i ]
     
132.                     ) );
     $ |0 Y' y" V4 G/ K9 z
133.             UF_CALL ( UF_SO_create_point_on_curve
     6 }- c5 [* Z) y
134.                       (
     
135.                           edges [ i ],
     
136.                           UF_SO_update_after_modeling,
     * v/ S: X: q. Z/ I+ o" M* c9 G
137.                           edges [ i ],
     " f1 v1 \% q2 R
138.                           scalars [ i ],
     
139.                           &points [ i ]
     , k5 b; E6 S( b$ u$ t7 n
140.                     ) );
     % z2 Q) I' U  r1 |
141.         }
     
142.         UF_CALL ( UF_SO_create_arc_center_2_pnts
     ! l. _9 `- H: [; H7 m; c' B
143.                  (
     
144.                       points [ 0 ],
     
145.                       UF_SO_update_after_modeling,
     4 B. o9 b9 _% m2 C" [
146.                       points,
     2 j$ E2 S2 `; q0 J0 v
147.                       &arc
     
148.                   ) );
     
149.     }
     " M% Q3 Z3 l' @* E
150.         
     
151.     /*
     1 y8 n) W4 w' Z) d! {7 v
152.        Smart objects are created as invisible objects by
     
153.        default.  UF_SO_set_visibility_option ( ) can be
     
154.        used to make them visible in the graphics window.
     2 X2 [1 {! U, B, Y' k- e2 ^. m
155.     */
     9 V4 Y' R* _" n. w2 O
156.     UF_CALL ( UF_SO_set_visibility_option ( line,
     
157.                                             UF_SO_visible ) );
     
158.     UF_CALL ( UF_SO_set_visibility_option ( arc,  
     
159.                                             UF_SO_visible ) );
     
160.     /*  
     4 K7 O" k( G3 ^, d' i2 `
161.         Get line/arc/edge evaluators.
     
162.     */
     ' [6 P) k- x: [- J! B' Y
163.     UF_CALL ( UF_EVAL_initialize ( line, &line_evaluator ) );
     - g& e2 @; c4 o
164.     UF_CALL ( UF_EVAL_initialize ( arc,  &arc_evaluator ) );
     ! P6 D1 B9 F' I  y
165.     UF_CALL ( UF_EVAL_initialize ( edge, &edge_evaluator ) );
     
166.     show_edge_points(line_evaluator, 10);
     9 m/ K3 U" V1 k8 B# I8 M: ^
167.     show_edge_points(arc_evaluator, 10);
     
168.     show_edge_points(edge_evaluator, 10);
     
169.     /*  
     
170.         Get line/arc/edge data.
     ' J- z4 t3 j9 G7 d% c
171.     */
     
172.     {
     
173.         UF_EVAL_line_t line_data;
     
174.         UF_EVAL_arc_t  arc_data;
     
175.         UF_EVAL_line_t edge_data;
     - B/ J: _* u9 p% e9 @" `
176.         UF_CALL ( UF_EVAL_ask_line ( line_evaluator,
     6 ?9 y+ i" a( A) `0 S7 {% |& H
177.                                      &line_data ) );
     6 X' @! [5 R. x
178.         UF_CALL ( UF_EVAL_ask_arc  ( arc_evaluator,  
     2 i' K8 ^$ ^7 J* N+ k
179.                                      &arc_data ) );
     * K4 [! X( t* V. g# w- P
180.         UF_CALL ( UF_EVAL_ask_line ( edge_evaluator,  
     
181.                                      &edge_data ) );
     2 A) C/ U- p8 j; ~3 s9 q; K5 \6 U
182.     }
     
183.     /*  
     ! V0 V2 h) E  G  K- r( s* A
184.         Check line/arc/edge periodicity.
       k+ m2 N4 z1 V- z# K
185.     */
     
186.     {
     
187.         logical is_periodic;
     
188.         
     3 M; r2 v  m* v
189.         UF_CALL ( UF_EVAL_is_periodic ( line_evaluator,
     $ z7 n) w. i9 S0 s, P, y4 G* ?4 x( d
190.                                         &is_periodic ) );
     
191.         UF_CALL ( UF_EVAL_is_periodic ( arc_evaluator,  
     
192.                                         &is_periodic ) );
     
193.         UF_CALL ( UF_EVAL_is_periodic ( edge_evaluator,  
       I. D# b8 i2 ], X6 Z8 l
194.                                         &is_periodic ) );
     
195.     }
     & A& P9 U+ @5 i' T3 |
196. /*  
     
197.         Evaluate line/arc/edge.
     ; H1 C* ]5 i! I
198. */
     / R$ }! m' W6 z( ]- H
199.     {
     6 b. p: z* t* J7 }& o
200.         double limits [ 2 ];        
     9 n0 i; a$ l# L# p
201.         double mid_t;
     
202.         double point [ 3 ];
     
203.         double derivative [ 3 ];
     
204.         double tangent [ 3 ];
     8 w% i6 n/ o! {
205.         double normal [ 3 ];
     
206.         double binormal [ 3 ];
     
207.         UF_CALL ( UF_EVAL_ask_limits ( line_evaluator, limits ) );
     
208.         mid_t = ( limits [ 1 ] + limits [ 0 ] ) / 2.0;
     
209.         UF_CALL ( UF_EVAL_evaluate ( line_evaluator,
       }" y2 ^# Y. ^$ I8 Y
210.                                      1,
     
211.                                      mid_t,
     4 F% \& A9 e5 [( q$ [
212.                                      point,
     
213.                                      derivative ) );
     
214.                   
     
215.         UF_CALL ( UF_EVAL_evaluate_unit_vectors ( line_evaluator,
     0 I1 h( C9 X  u) z. \6 F
216.                                                   mid_t,
     
217.                                                   point,
     # f. g' y4 o" \. X* L1 k0 T1 Q
218.                                                   tangent,
     
219.                                                   normal,
     
220.                                                   binormal ) );
     2 f( K7 m4 F7 b) \
221.         UF_CALL ( UF_EVAL_ask_limits ( arc_evaluator, limits ) );
     * E# I- U0 G: v4 ~  V! y. p+ e( k8 P
222.         mid_t = ( limits [ 1 ] + limits [ 0 ] ) / 2.0;
     
223.         
     
224.         UF_CALL ( UF_EVAL_evaluate ( arc_evaluator,
     1 E8 p; P6 D. Q1 W  w5 _; c
225.                                      1,
     
226.                                      mid_t,
     
227.                                      point,
     5 D8 o; a/ U0 ?% F' Q. _
228.                                      derivative ) );
     4 T& r$ ^4 k- l
229.         
     $ k% O/ S& e) x0 O
230.         UF_CALL ( UF_EVAL_evaluate_unit_vectors ( arc_evaluator,
     
231.                                                   mid_t,
     * t+ g4 W3 m! W7 H, {5 U1 Y
232.                                                   point,
     + Q7 W1 V5 x1 ~4 X2 X- y+ @9 d: |
233.                                                   tangent,
     
234.                                                   normal,
     
235.                                                   binormal ) );
     
236.         UF_CALL ( UF_EVAL_ask_limits ( edge_evaluator, limits ) );
     $ i: \( W+ Y% U! D7 X
237.         mid_t = ( limits [ 1 ] + limits [ 0 ] ) / 2.0;
     
238.         UF_CALL ( UF_EVAL_evaluate ( edge_evaluator,
     
239.                                      1,
     ; o/ }' N* ^: H. z, N: V- {6 W' G
240.                                      mid_t,
     - V: k: e2 B( V2 u2 W# U
241.                                      point,
     
242.                                      derivative ) );
     
243.         UF_CALL ( UF_EVAL_evaluate_unit_vectors ( edge_evaluator,
     
244.                                                   mid_t,
     
245.                                                   point,
     
246.                                                   tangent,
     
247.                                                   normal,
     
248.                                                   binormal ) );
     " A% R: f* p/ i/ \$ U" V# l4 U# J7 e
249.     }
     7 p7 P  S: v$ u  Y2 }  G) G" a3 X
250.     /*  
     
251.         Check line/arc/edge equality of evaluators.
     
252.     */
       ^/ o$ w- e6 i+ v- A" q
253.     {
     3 K& v) P! S: B6 x( s6 R) W
254.         logical is_equal;
     
255.         UF_EVAL_p_t line_evaluator_copy;
     
256.         UF_CALL ( UF_EVAL_copy ( line_evaluator,
     
257.                                  &line_evaluator_copy ) );
     ' F* P1 o0 p' Y( ^- U
258.         UF_CALL ( UF_EVAL_is_equal ( line_evaluator,
       `" l/ b: u0 j( x! B# @/ g& N% P. F
259.                                      line_evaluator_copy,
     ! p6 _4 ?4 v' W* W' m
260.                                      &is_equal ) );
     - R, p" u% b1 Q& k
261.         UF_CALL ( UF_EVAL_free ( line_evaluator_copy ) );
     ( N* N% x6 M6 U, y' X* x* x
262.         UF_CALL ( UF_EVAL_is_equal ( line_evaluator,
     
263.                                      arc_evaluator,
     . Z6 k# W$ O* \
264.                                      &is_equal ) );
     ' c$ @8 k" {# \1 N# c# ]
265.         UF_CALL ( UF_EVAL_is_equal ( line_evaluator,
     
266.                                      edge_evaluator,
     + _7 T9 g, W4 z8 z. g
267.                                      &is_equal ) );
     2 {, A0 w+ s, z1 ]7 {! R& O
268.     }
     6 M' c$ a! g. M# {- C, e
269.     /*  
     
270.         Check line/arc/edge type.
     9 E+ C4 K* S- H* ^9 h' y
271.     */
     6 @# y& v& h' O: d  x5 _
272.     {
     
273.         logical is_line;
     - f3 I9 `& k( B( f; Y2 q+ n
274.         logical is_arc;
     0 z* W8 M; l2 G5 @" y2 @  `4 @
275.         UF_CALL ( UF_EVAL_is_line ( line_evaluator, &is_line ) );
     9 M' I8 m+ |" F( Y0 @4 p$ i! D4 c4 P  h2 F
276.         UF_CALL ( UF_EVAL_is_arc  ( line_evaluator, &is_arc ) );
     1 M- O# E6 z% u0 v/ |2 e0 k
277.         UF_CALL ( UF_EVAL_is_arc  ( arc_evaluator,  &is_arc ) );
     0 P2 L/ b4 J) t, V2 y
278.         UF_CALL ( UF_EVAL_is_line ( arc_evaluator,  &is_line ) );
     # u' r! Q# R. K  A
279.         UF_CALL ( UF_EVAL_is_arc  ( edge_evaluator, &is_arc ) );
     ' V. c- }9 x9 q# K/ c0 T
280.         UF_CALL ( UF_EVAL_is_line ( edge_evaluator, &is_line ) );
     
281.     }
     
282.     UF_CALL ( UF_EVAL_free ( line_evaluator ) );
     
283.     UF_CALL ( UF_EVAL_free ( arc_evaluator ) );
     
284.     UF_CALL ( UF_EVAL_free ( edge_evaluator ) );
     9 e: w$ X& ^# p. R0 G* t1 S
285.     UF_CALL ( UF_terminate ( ) );
     
286. }
     % K" ?( x4 P( l+ ~: k
287. 
     : t! ?5 }# ]2 F* L8 A
288. /* This function will disply n_pts equally spaced along the
     ( L# t. q7 d& t* `" k
289.    input curve.
     " Q( j$ S1 n7 v; a* [
290. */
     
291. static void show_edge_points(UF_EVAL_p_t eval, int n_pts)
     ( h1 A) M! F5 z: W/ ~9 h7 P
292. {
     
293.     int ii;
     
294.     double limits[2], p, point[3], end_parameter, start_parameter;
     ' A' N( D% N8 U! {" `" x: M
295.     UF_OBJ_disp_props_t
     
296.         attrib = { 1, UF_OBJ_WHITE, UF_OBJ_NOT_BLANKED, UF_OBJ_WIDTH_NORMAL,
     8 v- s( W1 f0 e3 E& }
297.             UF_OBJ_FONT_SOLID, FALSE};
     
298. 
     $ g/ o# I# Y* A# X
299.     UF_CALL(UF_EVAL_ask_limits(eval, limits));
     
300.     printf ( "limit0 = %f\n", limits[0] );
     
301.     printf ( "limit1 = %f\n", limits[1] );
     
302.     start_parameter = limits[0];
     / L. F& A6 L5 [: b, H  I
303.     end_parameter = limits[1];
     
304. 
       l& E( P6 q: ^! J: }. n
305.     for (ii = 0; ii < n_pts; ii++)
     
306.     {
     / P8 W5 R9 y0 X8 @5 ~
307.         p =start_parameter + ii*((end_parameter - start_parameter)/(n_pts - 1));
     & l+ h& G7 A# {. r8 C+ u) O
308.         printf ( "evaluate = %f\n", p );
     2 Z* ~  s! Y$ T3 V1 Y& s
309.         UF_CALL(UF_EVAL_evaluate(eval, 0, p, point, NULL));
     
310.         UF_CALL(UF_DISP_display_temporary_point(NULL_TAG,
     
311.             UF_DISP_USE_ACTIVE_PLUS, point, &attrib, UF_DISP_POINT));
     ( r9 \2 o' F* K
312.     }
     # P* O& J1 c8 X3 f* B/ S
313. 
       z8 Z0 \( _/ Q1 g# I) d( R
314. }
     

复制代码

; N1 O' ~: [1 a% m/ h2 T, q