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

admin

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

1. #include <uf_defs.h>
   
2. #include <uf.h>
   
3. #include <uf_modl.h>
   
4. #include <uf_object_types.h>
   
5. #include <uf_ui.h>
   ' e: @: U) @( D0 C9 q* S  E
6. #include <uf_modl.h>
   ( u) {1 o; e& q1 ~3 V, ?+ R
7. #include <NXOpen/NXException.hxx>
   + l9 t  S5 m; E* m2 u0 Z$ V2 D/ e
8. #include <NXOpen/Session.hxx>
   % ]6 N) e: v! {
9. #include <NXOpen/Selection.hxx>
   
10. #include <NXOpen/Builder.hxx>
    
11. #include <NXOpen/Features_Feature.hxx>
    $ k; I- q/ C' ~
12. #include <NXOpen/Features_FeatureBuilder.hxx>
    9 g3 x! M  R" n( n& v
13. #include <NXOpen/Features_FeatureCollection.hxx>
    
14. #include <NXOpen/Features_GeometricConstraintData.hxx>
    
15. #include <NXOpen/Features_GeometricConstraintDataManager.hxx>
    
16. #include <NXOpen/Features_StudioSplineBuilder.hxx>
    * Z7 h: i. C8 T! `5 W
17. #include <NXOpen/Part.hxx>
    ) A2 \' ~( q7 r$ V& _" q+ T) t* w
18. #include <NXOpen/ParTCollection.hxx>
    
19. #include <NXOpen/Point.hxx>
    
20. #include <NXOpen/PointCollection.hxx>
    
21. #include <NXOpen/NXString.hxx>
    5 t* ~& T7 ~  n' W! K7 ~
22. #include <NXOpen/UI.hxx>
    
23. #include <NXOpen/Spline.hxx>
    
24. #include <NXOpen/NXObjectManager.hxx>
    
25. 
    ; ?* k$ C! W7 U  q/ J: l3 H
26. using namespace NXOpen;
    : {) K% ^9 {% O
27. using namespace std;
    ; g' y5 f2 ]: L3 ?
28. 
    7 b* ]6 |5 \$ w& H( d
29. extern "C" DllExport int ufusr_ask_unload()
    ) v2 [2 g! S) ?( p( F1 P1 Q  c5 v
30. {
    1 Z' `: W0 q# N8 J
31.     return (int)Session::LibraryUnloadOptionImmediately;
    ) d, r( l7 q( G* f4 ^3 e+ {- {
32. }
    + O7 K0 K' N3 \% p
33. 
    
34. static vector<Point *> selectPoints(NXString prompt)
    " f7 S( h' P8 M) Y% {. M
35. {
    
36.     UI *ui = UI::GetUI();
    
37.     Selection *sm = ui->SelectionManager();
    % M+ y, K; ^7 i0 m; E2 Y0 `6 H
38.     std::vector<Selection::MaskTriple> mask(1);
    
39.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
    ) }7 `4 n: r/ d$ o( B7 d$ q
40.     std::vector<NXObject *> objects;
    , [; h" s7 l! _2 V, W
41. 
    + f) c9 s9 b/ C  W; K
42.     sm->SelectObjects("Select Points", prompt,
    , J& L" v( n8 q" n
43.         Selection::SelectionScopeAnyInAssembly,
    
44.         Selection::SelectionActionClearAndEnableSpecific,
    
45.         false, false, mask, objects);
    
46. 
    
47.     vector<Point *>selPoints(objects.size());
    
48.     for (unsigned int ii = 0; ii < objects.size(); ii++)
    1 s$ C8 Y0 n2 v; Y& r3 S! n
49.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    
50. 
    
51.     return selPoints;
    & _: M9 X4 t- C' E, C6 d
52. }
    
53. 
    " }; W8 N- l8 e1 ?! ]& L( k% p1 {
54. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    
55. {
    
56.     Session *theSession = Session::GetSession();
    - ~+ r4 E5 Q) a% `% _! {+ |
57.     Part *workPart(theSession->Parts()->Work());
    
58. 
    9 F' P; S. _) Z% {9 |( |
59.     Session::UndoMarkId markId1;
    
60.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    8 q/ r" d$ B* ^9 ^' W  [
61.         "Studio Spline Thru Points");
    
62. 
    
63.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    ( }; Q0 G0 d4 F6 p: z
64. 
    # [$ b4 Z) J- C( i
65.     Features::StudioSplineBuilder *studioSplineBuilder1;
    % e; Q5 g# H4 i. X0 F& L# ^& }' M
66.     studioSplineBuilder1 = workPart->Features()->
    % b% ^, z  Y7 Z
67.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    / U: B6 ]/ y3 N8 l
68.     studioSplineBuilder1->SetAssociative(true);
    9 j1 d: g0 I  R! A* K
69.     studioSplineBuilder1->
    ; X/ k3 c+ ]7 w; S
70.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
      [) s) p- L) Q/ _& j
71.     studioSplineBuilder1->
    0 @# N+ i/ B+ x" E- D8 w8 I
72.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
    ; M  Y: M  r3 w4 E
73.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    
74.     studioSplineBuilder1->SetPeriodic(false);
    1 U5 q$ i  s. i0 y: C
75.     studioSplineBuilder1->
    
76.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    - V6 K- D: k! d
77.     std::vector<double> knots1(0);
    
78.     studioSplineBuilder1->SetKnots(knots1);
    
79.     std::vector<double> parameters1(0);
    - z+ `; Z7 _9 |4 A8 e
80.     studioSplineBuilder1->SetParameters(parameters1);
    & X. \) I! |4 G4 [5 P$ W9 ~
81.     Direction *nullDirection(NULL);
    
82.     Scalar *nullScalar(NULL);
    
83.     Offset *nullOffset(NULL);
    
84. 
    , q3 m6 J! C- u0 E+ }* k- ^
85.     std::vector<Features::GeometricConstraintData *>
    / g  b! Z8 r, C. Y3 t7 }& f; H3 b
86.         geometricConstraintData(thePoints.size());
    $ r" V9 E- C4 c( r
87. 
    5 H8 |5 Z7 e! D3 V- k3 S, Y
88.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    + J* o* V0 n2 F9 O
89.     {
    1 w1 _+ F, T9 `6 k
90.         geometricConstraintData[ii] = studioSplineBuilder1->
    6 L- Z/ q2 N% F- O2 |& Q; v' S
91.             ConstraintManager()->CreateGeometricConstraintData();
    
92.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    9 u: E- O/ D( t, Z( _; D8 \9 H
93.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    ' Y4 @& Y( J9 W$ W  u
94.             Features::GeometricConstraintData::ParameterDirectionIso);
    3 W/ r9 N, m& _/ ~6 L5 P( X+ k
95.         geometricConstraintData[ii]->SetAutomaticConstraintType(
    0 J. x6 q- F  ^. O
96.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    ' W( x$ C# Q: k7 @$ V
97.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    ' K  j: E$ U2 _( R5 {4 k
98.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
    ; U8 Y! C- e. o$ ^# w+ n* m
99.         geometricConstraintData[ii]->SetCurvature(nullOffset);
    
100.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
     
101.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     $ ]! I  t# @$ Y- ~% j! Q
102.     }
     ; c- @# x3 T3 F+ h/ F  K* q
103. 
     0 f! k% {  c; w( t( x) o
104.     studioSplineBuilder1->ConstraintManager()->SetContents(
     . {0 q/ B% i2 W  J( Y
105.         geometricConstraintData);
     7 y1 x9 C! Y! {3 P- N+ L6 t
106. 
     
107.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     
108.     Spline *theSpline = studioSplineBuilder1->Curve();
     $ A1 k' B* a) L; A
109. 
     
110.     studioSplineBuilder1->Destroy();
     $ i# ^; g/ `- j' l6 u& t7 \
111. 
     / K9 n/ r3 N& B
112.     return theSpline;
     % }% {0 W" \" Q7 T
113. }
     8 R6 H8 T, f+ h" t+ F
114. 
     2 j* k1 @% O0 X! ~; k
115. extern "C" DllExport void ufusr(char *param, int *retcod, int param_len)
     , E- v3 i5 }+ X+ z
116. {
     ) |* e0 g3 r6 c2 C
117.     std::vector<Point *>thePoints = selectPoints("Studio Spline Thru Points");
     3 o$ z$ t, d  x
118.     if (!thePoints.size()) return;
     7 ?7 A* a! t6 D- I
119. 
     3 U# w' d* N/ u$ Q
120.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     
121. 
     ' H8 E6 Q) e1 y$ F
122.     if (theSpline)
     
123.     {
     
124.         theSpline->Highlight();
     0 @# b+ l1 v6 {7 b' \& k+ w( Y
125.         uc1601("Studio Spline Created Thru Points", TRUE);
     * u5 P! y2 S2 x# m) a5 O: w3 |
126.         theSpline->Unhighlight();
     
127.     }
     " |9 a- c! `% Q0 k. ^! Y7 |5 o
128. }
     ! o2 b1 k$ R, T- H

复制代码

' ]9 N) `. K2 K0 I