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

admin

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

1. #include <uf_defs.h>
   
2. #include <uf.h>
   
3. #include <uf_modl.h>
   % }' ?4 T& K' E! X7 q! I8 _
4. #include <uf_object_types.h>
   
5. #include <uf_ui.h>
   
6. #include <uf_modl.h>
   ) l; f. H* ?+ J  ~  ^& n5 l6 ~
7. #include <NXOpen/NXException.hxx>
   ( E. R+ q/ l2 s' F$ u& D( Q
8. #include <NXOpen/Session.hxx>
   / d; ?, Y3 m7 }% G0 J
9. #include <NXOpen/Selection.hxx>
   ! c' }+ B* N% n' O
10. #include <NXOpen/Builder.hxx>
    
11. #include <NXOpen/Features_Feature.hxx>
    
12. #include <NXOpen/Features_FeatureBuilder.hxx>
    
13. #include <NXOpen/Features_FeatureCollection.hxx>
    
14. #include <NXOpen/Features_GeometricConstraintData.hxx>
    
15. #include <NXOpen/Features_GeometricConstraintDataManager.hxx>
    
16. #include <NXOpen/Features_StudioSplineBuilder.hxx>
    6 l3 {/ ~( T* ?. y0 R# S
17. #include <NXOpen/Part.hxx>
    
18. #include <NXOpen/ParTCollection.hxx>
    - l1 S* W8 x+ i# K/ ?3 z$ k: C
19. #include <NXOpen/Point.hxx>
    
20. #include <NXOpen/PointCollection.hxx>
    * Z( q7 a# f+ ]" T( U5 M
21. #include <NXOpen/NXString.hxx>
    / r: s( u: F- f+ g" A5 k
22. #include <NXOpen/UI.hxx>
    
23. #include <NXOpen/Spline.hxx>
    
24. #include <NXOpen/NXObjectManager.hxx>
    
25. 
    ; r7 ~9 |7 H' }1 E& ~% l4 S) M1 o- y$ j( u! Q
26. using namespace NXOpen;
    , u' w  B0 l) G5 Q' p7 Z
27. using namespace std;
    
28. 
    + a9 @% r, P2 N# h! D
29. extern "C" DllExport int ufusr_ask_unload()
    
30. {
    
31.     return (int)Session::LibraryUnloadOptionImmediately;
    
32. }
    
33. 
    # x% N- s2 ]" W( `
34. static vector<Point *> selectPoints(NXString prompt)
    
35. {
    4 M* |8 s+ d* r) f2 y: S- A5 ^. v
36.     UI *ui = UI::GetUI();
    
37.     Selection *sm = ui->SelectionManager();
    % V; d* T9 Y0 |8 U: O# V$ b0 B$ s- O
38.     std::vector<Selection::MaskTriple> mask(1);
    ! _9 \* w. K1 T  K4 A+ L
39.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
    
40.     std::vector<NXObject *> objects;
    
41. 
    ) T* S& z) ~0 i* y8 G
42.     sm->SelectObjects("Select Points", prompt,
    % Q- Q' [6 u: f* O8 ~
43.         Selection::SelectionScopeAnyInAssembly,
    " c+ a# A  `: t) J1 o, u# I; A7 ?
44.         Selection::SelectionActionClearAndEnableSpecific,
    
45.         false, false, mask, objects);
    
46. 
    3 w7 a0 W0 i" |2 ?
47.     vector<Point *>selPoints(objects.size());
    ! ^$ b) E! D# ~, T: m. g( i
48.     for (unsigned int ii = 0; ii < objects.size(); ii++)
    4 a: K( v6 Y2 u# V2 u. v) S
49.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    ) ^" j3 C. w& [0 X
50. 
    
51.     return selPoints;
    
52. }
    5 q/ a# f( d* l* U3 Z8 a
53. 
    
54. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    ' x' t% X# d* K6 T. b1 \
55. {
    3 \* c9 Q, K2 P- j3 @' n
56.     Session *theSession = Session::GetSession();
    
57.     Part *workPart(theSession->Parts()->Work());
    8 P* n* h7 k1 \9 f& p* a
58. 
    / B4 N8 F& J6 q
59.     Session::UndoMarkId markId1;
    
60.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    
61.         "Studio Spline Thru Points");
    9 N2 z, q! T9 j& F1 V; |
62. 
    
63.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    
64. 
    
65.     Features::StudioSplineBuilder *studioSplineBuilder1;
    8 B6 z' M) @" F6 O# X+ ~( B. z
66.     studioSplineBuilder1 = workPart->Features()->
    
67.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    
68.     studioSplineBuilder1->SetAssociative(true);
    
69.     studioSplineBuilder1->
    + t8 W: ?. c0 C5 o$ X
70.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
    ! U2 ^5 ]" d/ f( m
71.     studioSplineBuilder1->
    
72.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
    
73.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    * P6 h" E0 F6 m+ B) O1 F
74.     studioSplineBuilder1->SetPeriodic(false);
    $ c+ |* ~0 r) K' n# O
75.     studioSplineBuilder1->
    
76.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    : y! _, u& e* x, \# \( j( R
77.     std::vector<double> knots1(0);
    
78.     studioSplineBuilder1->SetKnots(knots1);
    3 K1 k9 j) }$ `) _
79.     std::vector<double> parameters1(0);
    7 U7 @4 P  R2 @5 f/ m+ b3 T; X
80.     studioSplineBuilder1->SetParameters(parameters1);
    1 T5 u; N  P4 |3 |6 K
81.     Direction *nullDirection(NULL);
    
82.     Scalar *nullScalar(NULL);
    
83.     Offset *nullOffset(NULL);
    2 X+ Q6 \" T' K. M# `
84. 
    
85.     std::vector<Features::GeometricConstraintData *>
    $ F. K& W( d  j$ J/ [
86.         geometricConstraintData(thePoints.size());
    
87. 
    
88.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    ! F0 |5 T2 G1 m& C3 r. y
89.     {
    ' u& |+ @' b% t+ |
90.         geometricConstraintData[ii] = studioSplineBuilder1->
    
91.             ConstraintManager()->CreateGeometricConstraintData();
    
92.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    
93.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    
94.             Features::GeometricConstraintData::ParameterDirectionIso);
    
95.         geometricConstraintData[ii]->SetAutomaticConstraintType(
      G6 k1 n5 _) z' Y7 L! f7 H# _
96.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    ( G! s% K2 }9 [7 w
97.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    , l1 v! p- t0 b
98.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
    ! L  z. x# _9 H0 @$ D" |
99.         geometricConstraintData[ii]->SetCurvature(nullOffset);
    : I" c. X8 M  f8 k1 t+ {/ O( m& u, @) f
100.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
     2 x, a, |+ V$ [0 ?* P7 g: q
101.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     2 m  I' w2 q( I! K9 M, D8 ^( ]
102.     }
     : J* ^2 @6 H5 c+ {
103. 
     
104.     studioSplineBuilder1->ConstraintManager()->SetContents(
     ( C9 E3 H8 |' z- X, |' S, G! _! |, d
105.         geometricConstraintData);
     
106. 
     7 P3 r  R/ r: s: x
107.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     : x- u, T, S) p+ x, k8 T/ f6 s+ d2 F
108.     Spline *theSpline = studioSplineBuilder1->Curve();
     
109. 
     
110.     studioSplineBuilder1->Destroy();
     
111. 
     
112.     return theSpline;
     
113. }
     ! C: E2 x- L( W- _
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");
     
118.     if (!thePoints.size()) return;
     
119. 
     - f6 {) {: r: t" ]+ Z& ~) b* O
120.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     ) \6 I! E+ X: Y" s
121. 
     . j1 \% ^, D, T* Z
122.     if (theSpline)
     9 L7 F8 v6 D- ]
123.     {
     
124.         theSpline->Highlight();
     1 u0 k& |9 x& ~; t  W# m( m/ e1 l
125.         uc1601("Studio Spline Created Thru Points", TRUE);
     " P- V, R9 p1 u
126.         theSpline->Unhighlight();
     0 @* M: Q* V& p: b. E
127.     }
     # y- I' E" N) ]) O" V. `" m
128. }
     

复制代码

4 E& ^: G& C. E& Y/ o2 u( d
# z7 D  O- `# {: F. ]