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

admin

NX二次开发源码： 通过点创建样条曲线
+ i8 D( b# z- x; F1 e7 ^# E

1. #include <uf_defs.h>
   
2. #include <uf.h>
   9 e# ?) r6 H  ~! @$ B
3. #include <uf_modl.h>
   ) v* b8 W# ?  S, |( G1 W& A
4. #include <uf_object_types.h>
   ' P7 t( I/ g1 Q! L5 I
5. #include <uf_ui.h>
   1 \* a; \* S% m. a( S( |
6. #include <uf_modl.h>
   
7. #include <NXOpen/NXException.hxx>
   . e: G; [" U  T  G! }9 \/ E' T
8. #include <NXOpen/Session.hxx>
   
9. #include <NXOpen/Selection.hxx>
   ; x! ?! `0 i4 f9 ^8 D5 @
10. #include <NXOpen/Builder.hxx>
    ' m! n9 d# m* N# f
11. #include <NXOpen/Features_Feature.hxx>
    2 q) E6 F3 _& [& B8 R6 J
12. #include <NXOpen/Features_FeatureBuilder.hxx>
    4 L2 e# G/ m, R; o. l+ E
13. #include <NXOpen/Features_FeatureCollection.hxx>
    " w) [3 B3 Z; y4 l! k/ A" K1 B
14. #include <NXOpen/Features_GeometricConstraintData.hxx>
    1 \( J2 A# Q5 ]0 [# h
15. #include <NXOpen/Features_GeometricConstraintDataManager.hxx>
    4 |- m5 ?: M# E& K: z9 {) \* a
16. #include <NXOpen/Features_StudioSplineBuilder.hxx>
    
17. #include <NXOpen/Part.hxx>
    
18. #include <NXOpen/ParTCollection.hxx>
    
19. #include <NXOpen/Point.hxx>
    & K) ^* C- K1 D. `- \9 N
20. #include <NXOpen/PointCollection.hxx>
    & R  @, k- U8 I7 H- z6 W) P$ H+ n
21. #include <NXOpen/NXString.hxx>
    ; v; H& A  A) ]. w. u! S
22. #include <NXOpen/UI.hxx>
      U' S: C3 D2 I' y) h
23. #include <NXOpen/Spline.hxx>
    & b+ T# T8 V7 b) S/ y7 ?6 [1 b
24. #include <NXOpen/NXObjectManager.hxx>
    1 g( l" U9 M% ~
25. 
    
26. using namespace NXOpen;
    
27. using namespace std;
    2 g9 [, z# b  R
28. 
    ( h% e9 k% S8 i: C
29. extern "C" DllExport int ufusr_ask_unload()
    
30. {
    . J2 A- w4 C4 M9 o8 G9 l0 b5 I2 E" G2 q1 p
31.     return (int)Session::LibraryUnloadOptionImmediately;
    0 [9 \) k7 Q. _
32. }
    & K$ m, r5 c8 _. c3 g
33. 
    
34. static vector<Point *> selectPoints(NXString prompt)
    ' J* i. ]' Q. n; g5 k" _
35. {
    & y8 f5 c6 N' Z
36.     UI *ui = UI::GetUI();
    % r$ }% C. @; @5 q
37.     Selection *sm = ui->SelectionManager();
    ' f9 I0 |/ h0 E( O
38.     std::vector<Selection::MaskTriple> mask(1);
    
39.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
    % N  }$ Q+ h* [, l. r( ?3 m' A! v
40.     std::vector<NXObject *> objects;
    # }. e+ B3 ?" ]5 Z4 |
41. 
    * p! R: s: @: p& K9 [
42.     sm->SelectObjects("Select Points", prompt,
    
43.         Selection::SelectionScopeAnyInAssembly,
    
44.         Selection::SelectionActionClearAndEnableSpecific,
    % J$ Y: G' Y; b0 w
45.         false, false, mask, objects);
    
46. 
    , c' ]" X8 W6 @
47.     vector<Point *>selPoints(objects.size());
    
48.     for (unsigned int ii = 0; ii < objects.size(); ii++)
    / T3 r4 P# K. T# ?
49.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    
50. 
    
51.     return selPoints;
    ) F3 ]$ W, U! s/ W' E) q! z/ F* q
52. }
    3 i# V, I% ^4 n2 x) ~
53. 
    6 v% e0 d9 B+ T1 _
54. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    ' X. {8 b% D$ U: X4 }6 y
55. {
    
56.     Session *theSession = Session::GetSession();
    - z1 [. `6 {5 X: p+ L& O0 y
57.     Part *workPart(theSession->Parts()->Work());
    
58. 
    
59.     Session::UndoMarkId markId1;
    
60.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    # X8 o0 T% \! y3 o+ a8 g' S$ f
61.         "Studio Spline Thru Points");
    
62. 
    0 Z# K" T5 F  {  ]) f
63.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    
64. 
    
65.     Features::StudioSplineBuilder *studioSplineBuilder1;
    
66.     studioSplineBuilder1 = workPart->Features()->
    
67.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    
68.     studioSplineBuilder1->SetAssociative(true);
    $ |" E! Q+ u& S; I( }
69.     studioSplineBuilder1->
    . g. L( j# F" e) X
70.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
    
71.     studioSplineBuilder1->
    . }' }8 S6 s  u# G) N2 {2 ?* {
72.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
    
73.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    3 K6 J5 O  a2 ]- s, E
74.     studioSplineBuilder1->SetPeriodic(false);
    2 b. ^7 n: f8 e. R; j+ r
75.     studioSplineBuilder1->
    
76.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    % ^# L: _% ~7 l  O- c
77.     std::vector<double> knots1(0);
    8 z; f& e- k4 h( v/ X" A
78.     studioSplineBuilder1->SetKnots(knots1);
    
79.     std::vector<double> parameters1(0);
    
80.     studioSplineBuilder1->SetParameters(parameters1);
    2 a0 w3 V* e9 P2 Q; e1 {* @
81.     Direction *nullDirection(NULL);
    # j5 l: \* V1 y( z  o: G% y9 E
82.     Scalar *nullScalar(NULL);
    
83.     Offset *nullOffset(NULL);
    
84. 
    1 X4 {8 D/ B3 B) ]
85.     std::vector<Features::GeometricConstraintData *>
    
86.         geometricConstraintData(thePoints.size());
    1 I  ~) e7 [3 `2 r2 R! O
87. 
    
88.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    8 Q" b5 w2 j; D, Y0 Q, G  N9 F
89.     {
    
90.         geometricConstraintData[ii] = studioSplineBuilder1->
    ; F" n$ Y1 g" ~7 ]& |7 ^5 \
91.             ConstraintManager()->CreateGeometricConstraintData();
    . {" t; m: ?. `* `9 f7 O% l$ X  }  C
92.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    
93.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    
94.             Features::GeometricConstraintData::ParameterDirectionIso);
    # k$ E" i) C! b$ x9 ~* G, |
95.         geometricConstraintData[ii]->SetAutomaticConstraintType(
    ( `- M/ X& X  n
96.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    
97.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    
98.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
    
99.         geometricConstraintData[ii]->SetCurvature(nullOffset);
    / F* p% h( O' M4 z) P) S
100.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
       g) R+ R/ |- a; |% B0 Y
101.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     $ p% I! M4 C* Q* e% z/ t! C3 j
102.     }
     
103. 
     ! u: t: |# O8 O; v! M! i. R
104.     studioSplineBuilder1->ConstraintManager()->SetContents(
     % [+ V7 Q& q2 h) V+ F
105.         geometricConstraintData);
     4 Y5 {* t" e5 N: ~: J$ ]
106. 
     ' a# V( k. v7 C: }7 F1 ~( j! I& G
107.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     1 Q1 Z1 _8 O" c# G1 M
108.     Spline *theSpline = studioSplineBuilder1->Curve();
     
109. 
     
110.     studioSplineBuilder1->Destroy();
     
111. 
     0 I1 p- A6 x% _% U
112.     return theSpline;
     
113. }
     , [3 ^. l. U3 J9 L
114. 
     0 X- k0 D' u9 z9 L
115. extern "C" DllExport void ufusr(char *param, int *retcod, int param_len)
     
116. {
     
117.     std::vector<Point *>thePoints = selectPoints("Studio Spline Thru Points");
     - W9 m- y+ U$ J/ B
118.     if (!thePoints.size()) return;
     . y0 X! P" Y1 B. n) @; P. Y
119. 
     
120.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     
121. 
     $ T- v2 Y5 K& Q
122.     if (theSpline)
     
123.     {
     ( E* E% ^1 W0 m- y
124.         theSpline->Highlight();
     
125.         uc1601("Studio Spline Created Thru Points", TRUE);
     1 y: y9 O7 t$ q
126.         theSpline->Unhighlight();
     ! \# y* y# R6 F/ R4 {: l* w# b
127.     }
     
128. }
     

复制代码

4 q* O5 k4 A  O& Y0 E

) V; y( k& W/ c1 n+ k3 L6 v( ~