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

admin

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

1. #include <uf_defs.h>
   4 {! z7 H7 x# r, S) Q$ o2 y- Q. {: M
2. #include <uf.h>
   7 e# R. O* _1 U% n6 [
3. #include <uf_modl.h>
   5 k9 r7 j  B* a; B& `( u
4. #include <uf_object_types.h>
   * F. I* s+ n, y. z' `: O" Y: Z+ y
5. #include <uf_ui.h>
   . i0 T! s+ n2 e, S4 k( g
6. #include <uf_modl.h>
   
7. #include <NXOpen/NXException.hxx>
   
8. #include <NXOpen/Session.hxx>
   & m+ U7 F. z2 d
9. #include <NXOpen/Selection.hxx>
   1 @8 X, E( `5 @+ A( y' o. Z" t
10. #include <NXOpen/Builder.hxx>
    , H+ e; u- q3 _; R; ~
11. #include <NXOpen/Features_Feature.hxx>
    
12. #include <NXOpen/Features_FeatureBuilder.hxx>
    2 W) E( }$ a. s  {1 [& t# ?
13. #include <NXOpen/Features_FeatureCollection.hxx>
    ( T5 {7 Y3 V* L& W6 A9 y. q/ ^
14. #include <NXOpen/Features_GeometricConstraintData.hxx>
    ' T/ D$ d; u+ f2 a( t" M. N0 R
15. #include <NXOpen/Features_GeometricConstraintDataManager.hxx>
    
16. #include <NXOpen/Features_StudioSplineBuilder.hxx>
    
17. #include <NXOpen/Part.hxx>
    
18. #include <NXOpen/ParTCollection.hxx>
    4 E8 R: {9 t3 a3 k2 h. j
19. #include <NXOpen/Point.hxx>
    4 {- D& S9 |/ b# P4 k1 m
20. #include <NXOpen/PointCollection.hxx>
    / s, `4 s* ~3 ~
21. #include <NXOpen/NXString.hxx>
    
22. #include <NXOpen/UI.hxx>
    
23. #include <NXOpen/Spline.hxx>
    
24. #include <NXOpen/NXObjectManager.hxx>
    - f3 L# M1 C; [& X  ]% H
25. 
    
26. using namespace NXOpen;
    0 j% Q) e0 t1 F: `" i. Q% L
27. using namespace std;
    
28. 
    8 O& u" a" m- o; T0 E2 f8 ^+ |. g
29. extern "C" DllExport int ufusr_ask_unload()
    : F: i" o8 O% H8 T! t# z
30. {
    
31.     return (int)Session::LibraryUnloadOptionImmediately;
    3 f" m! X/ C/ o* }6 S
32. }
    * d1 ?. I/ e6 G
33. 
    ( K  G3 [1 N9 i
34. static vector<Point *> selectPoints(NXString prompt)
    # b- t3 I! K$ m: r* }* S/ Z
35. {
    , o) K! ~! f5 L% n, I7 Q2 M
36.     UI *ui = UI::GetUI();
    
37.     Selection *sm = ui->SelectionManager();
    . ^1 ^) I! n- ~: S. q0 f* M, w
38.     std::vector<Selection::MaskTriple> mask(1);
    6 c! u  `" {% h0 ?$ t! `
39.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
    - Z6 G9 w' M( B/ S2 w7 S( A$ R) t
40.     std::vector<NXObject *> objects;
    ; x7 X; r8 x' {1 h* G0 n' L( |
41. 
    8 W! ~8 v3 D+ ]8 K, ~, o; K+ t
42.     sm->SelectObjects("Select Points", prompt,
    
43.         Selection::SelectionScopeAnyInAssembly,
    
44.         Selection::SelectionActionClearAndEnableSpecific,
    
45.         false, false, mask, objects);
    - X2 U; n9 k4 F
46. 
    
47.     vector<Point *>selPoints(objects.size());
    * g* j' C1 x" X7 k& C. _
48.     for (unsigned int ii = 0; ii < objects.size(); ii++)
    7 _  u5 U) [, z6 X7 B
49.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    
50. 
    
51.     return selPoints;
    $ G4 Z( [1 V1 m5 T* B) t
52. }
    
53. 
    
54. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    ( Y4 i* Q0 Q; w( i7 `4 m
55. {
    " e1 f! `: T+ c  J, Q+ w
56.     Session *theSession = Session::GetSession();
    
57.     Part *workPart(theSession->Parts()->Work());
    7 G: Y+ p! E+ N4 P3 g5 G) O6 e1 `
58. 
    
59.     Session::UndoMarkId markId1;
    ( v6 ^5 @/ a1 D+ S2 [9 v7 ~, Q3 K/ ?4 ]
60.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    
61.         "Studio Spline Thru Points");
    
62. 
    ' c+ a, R' W3 `
63.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    : ]1 @3 }5 g) T, w5 j$ N9 H
64. 
    
65.     Features::StudioSplineBuilder *studioSplineBuilder1;
    
66.     studioSplineBuilder1 = workPart->Features()->
    % h% f) ~0 K3 J5 F3 r
67.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    
68.     studioSplineBuilder1->SetAssociative(true);
    
69.     studioSplineBuilder1->
    
70.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
    + k4 ~6 B4 Z) S1 y0 }: `* G
71.     studioSplineBuilder1->
    & A# A$ u9 K- H  X) c; u
72.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
    3 F1 S; U! X6 F  `& i
73.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    6 _6 i% ?" K; D+ R' S5 c
74.     studioSplineBuilder1->SetPeriodic(false);
    8 ]% c+ Y  L% X0 @  w1 s) b
75.     studioSplineBuilder1->
    . ?/ ^; b$ p- z6 g
76.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    9 i' T( [  R( Y( ?( @& J' u9 {
77.     std::vector<double> knots1(0);
    / \, Q% K- Q5 F& ?6 W
78.     studioSplineBuilder1->SetKnots(knots1);
    8 g2 R+ p4 k  Q2 `: X
79.     std::vector<double> parameters1(0);
    3 r( q' }; ?; M! T; [- R% u3 N/ n1 e  c
80.     studioSplineBuilder1->SetParameters(parameters1);
    & D# s/ w$ ^, U3 m. [
81.     Direction *nullDirection(NULL);
    9 V$ B" y1 o) j4 J' E. }
82.     Scalar *nullScalar(NULL);
    % j2 A0 u/ M- V) _* i1 {
83.     Offset *nullOffset(NULL);
    , K: Q9 Q1 V# K
84. 
    9 S/ _5 I, |( \' {( i0 f# E6 g4 A* h, b
85.     std::vector<Features::GeometricConstraintData *>
    
86.         geometricConstraintData(thePoints.size());
    
87. 
    
88.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    
89.     {
    
90.         geometricConstraintData[ii] = studioSplineBuilder1->
    . D7 l4 `0 y# J% Y6 F: n+ |
91.             ConstraintManager()->CreateGeometricConstraintData();
    
92.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    & `8 e+ f1 o+ `2 Z8 D3 C& f4 F! V
93.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    4 h) a' d# a: F- g- t' u2 h& m
94.             Features::GeometricConstraintData::ParameterDirectionIso);
    3 L8 G% r9 G. u. r* R
95.         geometricConstraintData[ii]->SetAutomaticConstraintType(
    4 o; x5 [: a; o9 n; y
96.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    / X0 g  g9 U+ L& e- X- N$ s) J
97.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    # i3 t: o/ q, A8 x0 c
98.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
    / O0 r& H# Y3 K; o
99.         geometricConstraintData[ii]->SetCurvature(nullOffset);
    3 m6 p. D0 u  z" Z* W8 H: u3 a
100.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
     
101.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     
102.     }
     
103. 
     , Q$ Y' B% P8 ^) ~3 |
104.     studioSplineBuilder1->ConstraintManager()->SetContents(
     1 o, `. v' m! @8 S( P# E
105.         geometricConstraintData);
     ; A$ ?/ e) x. }/ E8 e+ k8 D
106. 
     
107.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     
108.     Spline *theSpline = studioSplineBuilder1->Curve();
     : X9 B* [" G, P- |7 @/ e+ z( b& T
109. 
     
110.     studioSplineBuilder1->Destroy();
     
111. 
     
112.     return theSpline;
       q! ~! }# \$ d4 k! P
113. }
     
114. 
     & M% K$ e! e. b" \" o% T* u- _4 C# u
115. extern "C" DllExport void ufusr(char *param, int *retcod, int param_len)
     ! p/ j& H8 ^& f9 k0 T: |; ~; H0 S" C
116. {
     0 |. i  ~* z/ k* R6 K
117.     std::vector<Point *>thePoints = selectPoints("Studio Spline Thru Points");
     $ X, |2 |$ c( Z* }
118.     if (!thePoints.size()) return;
     3 x7 N: k- [2 ?/ ]
119. 
     
120.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     # ?& s# q) Y/ |6 E
121. 
     $ w) K; |# |1 q
122.     if (theSpline)
     . {1 i  ^( U! `6 _* k3 k- z! K  Y$ @
123.     {
     
124.         theSpline->Highlight();
     
125.         uc1601("Studio Spline Created Thru Points", TRUE);
     
126.         theSpline->Unhighlight();
     . G8 r/ \( g9 J  J5 c( i# J. A
127.     }
     
128. }
     

复制代码

% X6 w/ N' Q; E( a. C7 P