NX二次开发源码： 通过点创建样条曲线

admin

NX二次开发源码： 通过点创建样条曲线
; N2 R. A  V( F

1. #include <uf_defs.h>
   " ]+ V" ]0 Z- M
2. #include <uf.h>
   
3. #include <uf_modl.h>
     S* `, V0 f8 \: `
4. #include <uf_object_types.h>
   
5. #include <uf_ui.h>
   
6. #include <uf_modl.h>
   , l% e. l% |- z5 ]- L! L
7. #include <NXOpen/NXException.hxx>
   
8. #include <NXOpen/Session.hxx>
   2 T8 G( g$ A% b$ o
9. #include <NXOpen/Selection.hxx>
   ( Z* e# |% M  k% g5 ?
10. #include <NXOpen/Builder.hxx>
    
11. #include <NXOpen/Features_Feature.hxx>
    ' _1 M/ {8 B9 C
12. #include <NXOpen/Features_FeatureBuilder.hxx>
    
13. #include <NXOpen/Features_FeatureCollection.hxx>
    # q1 e9 s5 V, a7 g8 I5 L
14. #include <NXOpen/Features_GeometricConstraintData.hxx>
    8 \6 `3 v! X! ?' ~' {
15. #include <NXOpen/Features_GeometricConstraintDataManager.hxx>
    . t% P1 {7 R1 t* D% m- Q; d$ A/ z! o
16. #include <NXOpen/Features_StudioSplineBuilder.hxx>
    ; k' W! d' o" c
17. #include <NXOpen/Part.hxx>
    7 B! g6 ?) Y7 q9 e' H
18. #include <NXOpen/ParTCollection.hxx>
    
19. #include <NXOpen/Point.hxx>
    
20. #include <NXOpen/PointCollection.hxx>
    
21. #include <NXOpen/NXString.hxx>
    6 T) i& I/ V& T) `% j5 Q' E$ t$ d
22. #include <NXOpen/UI.hxx>
    
23. #include <NXOpen/Spline.hxx>
    . _- Q0 K8 F9 `
24. #include <NXOpen/NXObjectManager.hxx>
    ! p( v$ v0 D" A6 i- o( n5 i2 R, [
25. 
    
26. using namespace NXOpen;
    ; ~% S/ L5 H1 C+ F
27. using namespace std;
    * l+ F* }& P8 X; x' m& s& O/ Y$ v
28. 
    * c8 z3 Q# `1 R6 ]
29. extern "C" DllExport int ufusr_ask_unload()
    
30. {
    
31.     return (int)Session::LibraryUnloadOptionImmediately;
    ) a# j4 J# V' E6 L  X8 j
32. }
    
33. 
    
34. static vector<Point *> selectPoints(NXString prompt)
    
35. {
    
36.     UI *ui = UI::GetUI();
    ) P; Q% h. a9 u) v
37.     Selection *sm = ui->SelectionManager();
    
38.     std::vector<Selection::MaskTriple> mask(1);
    6 M  D7 A) A! ]& l' m
39.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
    
40.     std::vector<NXObject *> objects;
    # a/ f: |5 l0 ?4 k1 J
41. 
    1 j# g5 o% N. k
42.     sm->SelectObjects("Select Points", prompt,
    6 ?( r% a2 k6 S) s! `8 ?& L' I
43.         Selection::SelectionScopeAnyInAssembly,
    ! G9 r# y' k" w2 }
44.         Selection::SelectionActionClearAndEnableSpecific,
    5 n. D1 ?  V% |1 p7 L9 Z3 n
45.         false, false, mask, objects);
    8 `4 H2 C& @9 h6 H' I: B
46. 
    : _! U3 n, q+ p& Y% r
47.     vector<Point *>selPoints(objects.size());
    
48.     for (unsigned int ii = 0; ii < objects.size(); ii++)
    
49.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    * e2 L1 P4 s, {* u$ u: H
50. 
    - }9 k: O8 c) S) w0 @
51.     return selPoints;
    3 K+ b% y3 |/ F! a( o3 J. ^
52. }
    
53. 
    0 b" V; _) r$ ]
54. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    3 W* O6 Y. W/ O) m6 o( \$ R; z
55. {
    
56.     Session *theSession = Session::GetSession();
    $ r& w4 z# G: M) q" m5 _9 ]
57.     Part *workPart(theSession->Parts()->Work());
    
58. 
    
59.     Session::UndoMarkId markId1;
    
60.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    , l& M  {2 R  B, G  Q
61.         "Studio Spline Thru Points");
    
62. 
    
63.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    
64. 
    
65.     Features::StudioSplineBuilder *studioSplineBuilder1;
    3 e8 }# \8 Z& e6 r2 I
66.     studioSplineBuilder1 = workPart->Features()->
    # p& \; a+ C; R1 W5 D% \% k) P
67.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    ( X$ v& X# c* A" s3 l" p* B
68.     studioSplineBuilder1->SetAssociative(true);
    , K" b) m* |3 h7 Y
69.     studioSplineBuilder1->
    1 g" G* a& }* `/ S2 ^
70.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
    
71.     studioSplineBuilder1->
    
72.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
    ( q# |2 H) ~6 w3 w# q
73.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    
74.     studioSplineBuilder1->SetPeriodic(false);
    # ~  y, K/ |, P: w* y# ?
75.     studioSplineBuilder1->
    
76.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    
77.     std::vector<double> knots1(0);
    / d/ `5 E' [8 H4 i% I
78.     studioSplineBuilder1->SetKnots(knots1);
    
79.     std::vector<double> parameters1(0);
    
80.     studioSplineBuilder1->SetParameters(parameters1);
    
81.     Direction *nullDirection(NULL);
    ; T% ]$ o( R/ C% W* t' j7 }2 m  o
82.     Scalar *nullScalar(NULL);
    
83.     Offset *nullOffset(NULL);
    5 i0 j, q! G; |. `# y) _2 V' Y
84. 
    4 F2 Q  i  `* T3 \6 m: y, q/ E, X
85.     std::vector<Features::GeometricConstraintData *>
    
86.         geometricConstraintData(thePoints.size());
    % ?* _6 s4 ~! b- ~( Z
87. 
    
88.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    
89.     {
    ' ]/ |0 h8 F6 N8 s% A
90.         geometricConstraintData[ii] = studioSplineBuilder1->
    % b# i$ A8 `4 m  x7 p% p/ h# f
91.             ConstraintManager()->CreateGeometricConstraintData();
    ! Q' n; S( ^: I) M/ q
92.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    
93.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    ! w. m% n/ L+ L
94.             Features::GeometricConstraintData::ParameterDirectionIso);
    6 z7 n) [( k% H% Q
95.         geometricConstraintData[ii]->SetAutomaticConstraintType(
    7 B6 k% _" l! u' ?: Q+ D
96.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    
97.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    
98.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
    
99.         geometricConstraintData[ii]->SetCurvature(nullOffset);
    , I6 s1 w% x/ `$ w2 {
100.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
     ( d. g' X) ?1 p: W- n$ }
101.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     & ]  i& C, X( U) h- l
102.     }
     0 A" c. k  d) e
103. 
     ; ^3 v0 h! e2 Q* q3 P( Z
104.     studioSplineBuilder1->ConstraintManager()->SetContents(
     
105.         geometricConstraintData);
     
106. 
     ; @: p6 L7 o5 R4 k+ Q
107.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     $ Z) b  t" u' }+ p# j" j$ j3 k0 J
108.     Spline *theSpline = studioSplineBuilder1->Curve();
     / c( u$ i- s, O) ^' S* n: t+ D! z
109. 
     
110.     studioSplineBuilder1->Destroy();
     / \; N3 t$ ?" ?5 o; I  y8 O4 v1 b; u
111. 
     
112.     return theSpline;
     
113. }
     5 r5 y* d$ O7 Q; P
114. 
     
115. extern "C" DllExport void ufusr(char *param, int *retcod, int param_len)
     
116. {
     
117.     std::vector<Point *>thePoints = selectPoints("Studio Spline Thru Points");
     4 ?% B7 o- `  t% e% `  G
118.     if (!thePoints.size()) return;
     
119. 
     8 |  d* [( Y0 O8 l- n1 v
120.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     4 {7 l2 F% \2 O) N
121. 
     $ l9 Y7 H! P9 r; e4 p0 t
122.     if (theSpline)
     ; o% e6 u$ }( G7 K0 j; a" t7 k
123.     {
     8 K5 P( I0 V! J# o
124.         theSpline->Highlight();
     5 p8 K* J; c% K0 s; S$ z' I  H8 h
125.         uc1601("Studio Spline Created Thru Points", TRUE);
     4 q7 j8 }/ Q  H, I+ v
126.         theSpline->Unhighlight();
     
127.     }
     
128. }
     7 k0 [- r0 H# O3 r8 p- Z: h! b( K

复制代码

) X4 O( P& W) K+ D