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

admin

NX二次开发源码： 通过点创建样条曲线
' s7 N) ]% }9 j, O7 C

1. #include <uf_defs.h>
   7 n# D! c; U4 E- q
2. #include <uf.h>
   $ E- \* Y5 J. f1 v3 T  Y( {4 E8 ~
3. #include <uf_modl.h>
   ' t& Y/ e- e% m" H2 n; ~7 S
4. #include <uf_object_types.h>
   3 e# h% A( u4 `3 Z: X" X9 B
5. #include <uf_ui.h>
   
6. #include <uf_modl.h>
   
7. #include <NXOpen/NXException.hxx>
   
8. #include <NXOpen/Session.hxx>
   7 t2 E4 H% a" t, ]
9. #include <NXOpen/Selection.hxx>
   8 S2 H5 K5 t, T$ P3 f; z  _5 u1 e
10. #include <NXOpen/Builder.hxx>
    
11. #include <NXOpen/Features_Feature.hxx>
    
12. #include <NXOpen/Features_FeatureBuilder.hxx>
    
13. #include <NXOpen/Features_FeatureCollection.hxx>
    5 D! `0 O5 Z$ `/ Z9 s6 _8 i
14. #include <NXOpen/Features_GeometricConstraintData.hxx>
    
15. #include <NXOpen/Features_GeometricConstraintDataManager.hxx>
    
16. #include <NXOpen/Features_StudioSplineBuilder.hxx>
    % T+ N' G/ t' s  N
17. #include <NXOpen/Part.hxx>
    ; M/ i- d) U5 `, a
18. #include <NXOpen/ParTCollection.hxx>
    $ q& P. \6 q! s: |$ a; z
19. #include <NXOpen/Point.hxx>
    # N7 D/ k+ [9 K# y; i! f
20. #include <NXOpen/PointCollection.hxx>
    
21. #include <NXOpen/NXString.hxx>
    , a4 F+ f% I4 K
22. #include <NXOpen/UI.hxx>
    " w# P" x  M# G) R5 @8 H
23. #include <NXOpen/Spline.hxx>
    : T! }% I1 S3 I. D. \9 q! Q
24. #include <NXOpen/NXObjectManager.hxx>
    
25. 
    
26. using namespace NXOpen;
    # e, b, e0 D; c3 w# Q. A2 u& ^
27. using namespace std;
    : M5 y$ g* `* N0 c! M+ f- p9 _& @
28. 
    ! A: A( j+ z: E. j  o# G; K" C
29. extern "C" DllExport int ufusr_ask_unload()
    
30. {
    
31.     return (int)Session::LibraryUnloadOptionImmediately;
    
32. }
    
33. 
    
34. static vector<Point *> selectPoints(NXString prompt)
    
35. {
    
36.     UI *ui = UI::GetUI();
    7 O6 w0 L" S! I
37.     Selection *sm = ui->SelectionManager();
    2 ?8 m% K; N6 h5 Q6 b0 C, c1 f5 ~
38.     std::vector<Selection::MaskTriple> mask(1);
    
39.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
    
40.     std::vector<NXObject *> objects;
    
41. 
    
42.     sm->SelectObjects("Select Points", prompt,
    # n, F% {) p9 S
43.         Selection::SelectionScopeAnyInAssembly,
    ! `. O* ~: t8 ~5 `
44.         Selection::SelectionActionClearAndEnableSpecific,
    4 [2 M# K9 G" V! _- e# q$ K2 e/ Z
45.         false, false, mask, objects);
    8 d6 J( r7 t3 R; B$ s% t* s3 V$ i
46. 
    / S( @5 F* l. [8 Y! H  t- g+ f: r
47.     vector<Point *>selPoints(objects.size());
    8 x1 a  \- ]. u3 t- R; h' S
48.     for (unsigned int ii = 0; ii < objects.size(); ii++)
    ! j; K- k. g0 B( }! `
49.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    6 n  Z% N4 Z( z& a
50. 
    # ?7 z9 Y) R) u& ?* g
51.     return selPoints;
    - J$ l! T- T8 o- {' c
52. }
    3 {0 l% ]. n0 U+ ]
53. 
    ; y- A5 u3 H4 M) ~  A- G$ d
54. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    + g. L. R9 o4 a- u) R3 j) |
55. {
    6 w; F% Z7 ^. c4 {& G7 p1 c
56.     Session *theSession = Session::GetSession();
    
57.     Part *workPart(theSession->Parts()->Work());
    " Z, ?% t* h1 [3 B
58. 
    ! ?6 g1 H1 R& w3 Y. f4 W$ W
59.     Session::UndoMarkId markId1;
    
60.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    
61.         "Studio Spline Thru Points");
    * K7 h, e% i. y6 g3 `# `
62. 
    
63.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    - n! u1 ?6 e' |( J8 J: _" P
64. 
    
65.     Features::StudioSplineBuilder *studioSplineBuilder1;
    2 }. Q5 R( k& q7 v2 \3 j
66.     studioSplineBuilder1 = workPart->Features()->
    ! L5 ~9 q' |; m. O
67.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    
68.     studioSplineBuilder1->SetAssociative(true);
    ) F. ]* p  ^& @' Z" c
69.     studioSplineBuilder1->
    
70.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
    ; K& ]( u" l" _" L1 Q
71.     studioSplineBuilder1->
    
72.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
    # i0 V+ f4 g) C# T( d0 D6 q
73.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    
74.     studioSplineBuilder1->SetPeriodic(false);
    0 Y: d. p, V: i9 M1 m# E
75.     studioSplineBuilder1->
    8 V( V; i4 ^9 R! D
76.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    
77.     std::vector<double> knots1(0);
    , _1 h) B2 X/ W! o6 ?
78.     studioSplineBuilder1->SetKnots(knots1);
    
79.     std::vector<double> parameters1(0);
    
80.     studioSplineBuilder1->SetParameters(parameters1);
    & X9 p  W# F' B! i8 ^
81.     Direction *nullDirection(NULL);
    
82.     Scalar *nullScalar(NULL);
    ! {' L- V  W) i, @
83.     Offset *nullOffset(NULL);
    
84. 
    8 [8 A( y- R" V6 T( O  c4 h8 M
85.     std::vector<Features::GeometricConstraintData *>
    
86.         geometricConstraintData(thePoints.size());
    
87. 
    " _. v' M1 e6 ]2 J/ e
88.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    
89.     {
    4 @7 c( n5 ~: W3 n
90.         geometricConstraintData[ii] = studioSplineBuilder1->
    6 b6 S- n9 e" ^- j4 a; b
91.             ConstraintManager()->CreateGeometricConstraintData();
    
92.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    % b" A3 s/ X! y+ G4 b$ |  ]
93.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    
94.             Features::GeometricConstraintData::ParameterDirectionIso);
    . ]4 Z9 Q5 x8 ?
95.         geometricConstraintData[ii]->SetAutomaticConstraintType(
    2 A! j/ _7 H, g7 g5 e
96.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    
97.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    5 P1 t  ]1 g& X9 t, T- a+ x) e
98.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
    
99.         geometricConstraintData[ii]->SetCurvature(nullOffset);
    * U  n: \, Q/ i% U# I& H
100.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
     
101.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     
102.     }
     
103. 
     , W& g4 H, G# S
104.     studioSplineBuilder1->ConstraintManager()->SetContents(
     
105.         geometricConstraintData);
     9 m+ p0 @+ Z* U2 T5 z& ^2 k
106. 
     
107.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     
108.     Spline *theSpline = studioSplineBuilder1->Curve();
     
109. 
     
110.     studioSplineBuilder1->Destroy();
     
111. 
     
112.     return theSpline;
     8 i( t7 x: c0 B) u! D; t7 f
113. }
     0 I! F0 ~$ z3 d. Y
114. 
     
115. extern "C" DllExport void ufusr(char *param, int *retcod, int param_len)
     ' X- l% o* R. W! S2 e
116. {
     
117.     std::vector<Point *>thePoints = selectPoints("Studio Spline Thru Points");
     
118.     if (!thePoints.size()) return;
     
119. 
     : V9 w$ N. Z/ A3 S4 Z
120.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     
121. 
     
122.     if (theSpline)
     : Z# E$ l# P. Q1 K: Q6 k! ?. h* t
123.     {
     
124.         theSpline->Highlight();
     
125.         uc1601("Studio Spline Created Thru Points", TRUE);
     0 C& a6 _# A* b) g8 M0 W
126.         theSpline->Unhighlight();
     
127.     }
     
128. }
     ; x" g. Y6 h# S' Q

复制代码

. G) E3 [% p% k( z- T4 b7 V1 {" o; p
8 o5 G9 W  M2 `. }5 K& I8 o5 I! D2 n1 ^) A2 T