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

admin

NX二次开发源码： 通过点创建样条曲线
# l' {- a7 w% u

1. #include <uf_defs.h>
   2 e$ @" N" ]$ R  s  Z' D
2. #include <uf.h>
   $ S9 W) ~# v* _% i$ x/ z
3. #include <uf_modl.h>
   
4. #include <uf_object_types.h>
   
5. #include <uf_ui.h>
   ) ?' X5 i% a4 P
6. #include <uf_modl.h>
   & u3 w, i# C: O6 @
7. #include <NXOpen/NXException.hxx>
   
8. #include <NXOpen/Session.hxx>
   
9. #include <NXOpen/Selection.hxx>
   
10. #include <NXOpen/Builder.hxx>
    
11. #include <NXOpen/Features_Feature.hxx>
    
12. #include <NXOpen/Features_FeatureBuilder.hxx>
    ; s1 @: L2 s1 \4 f$ t
13. #include <NXOpen/Features_FeatureCollection.hxx>
    
14. #include <NXOpen/Features_GeometricConstraintData.hxx>
    ; m/ u, R5 Q- R# ?: M8 m8 v
15. #include <NXOpen/Features_GeometricConstraintDataManager.hxx>
    4 p, T1 B  o7 E1 w- ?
16. #include <NXOpen/Features_StudioSplineBuilder.hxx>
    ' s) o6 f' R& z  q( O0 ~
17. #include <NXOpen/Part.hxx>
    
18. #include <NXOpen/ParTCollection.hxx>
    * m: e9 \& Q: h0 o% Z
19. #include <NXOpen/Point.hxx>
    - ?: \) @. I* `0 U" ]
20. #include <NXOpen/PointCollection.hxx>
    + K4 n7 ]; r$ z1 k% z
21. #include <NXOpen/NXString.hxx>
    
22. #include <NXOpen/UI.hxx>
    
23. #include <NXOpen/Spline.hxx>
    
24. #include <NXOpen/NXObjectManager.hxx>
    
25. 
    1 L5 m' ?# b( J; `8 D
26. using namespace NXOpen;
    
27. using namespace std;
    . L; r& f2 N1 N8 k; B8 F
28. 
    1 T. }6 T. Q5 ?/ |# @
29. extern "C" DllExport int ufusr_ask_unload()
    # n  d# d* V, _5 J( Q+ _
30. {
    : d! T1 J* i$ ?6 U) x) F3 S. }
31.     return (int)Session::LibraryUnloadOptionImmediately;
    
32. }
    
33. 
    - w* y( P+ p' J/ v6 S
34. static vector<Point *> selectPoints(NXString prompt)
    3 G, D/ r" N. C% o$ L' h: Y
35. {
    2 h) O0 F$ u" K6 A4 w1 V0 I
36.     UI *ui = UI::GetUI();
    4 E2 c5 e6 a$ e% s+ D
37.     Selection *sm = ui->SelectionManager();
    
38.     std::vector<Selection::MaskTriple> mask(1);
    % L8 f' t# d6 u6 F' K. _  c9 _) @
39.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
    ! \* x, y8 n3 P; v9 K- X
40.     std::vector<NXObject *> objects;
    + Y9 U1 n- a3 L* a+ F' k- r
41. 
    
42.     sm->SelectObjects("Select Points", prompt,
    
43.         Selection::SelectionScopeAnyInAssembly,
    2 s5 g3 G1 B$ M/ B1 k& n6 n; z6 s' l7 g
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++)
    4 ]3 m9 v" c, @8 c! B" ?
49.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    " {0 b1 P. v' P2 e+ U" {
50. 
    
51.     return selPoints;
    
52. }
    " {* u" n# K$ {" h% l& Q4 }* b  J
53. 
    3 o0 X, J- I8 K6 Y  k
54. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    , i5 L6 e# t  x, m% `9 t* C/ H
55. {
    2 A3 o6 r- d# T5 b& `
56.     Session *theSession = Session::GetSession();
    
57.     Part *workPart(theSession->Parts()->Work());
    : e0 @( F" E$ P
58. 
    
59.     Session::UndoMarkId markId1;
    2 n5 U5 b. _! u
60.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    . O: m2 C$ \/ a
61.         "Studio Spline Thru Points");
    
62. 
    1 H& C/ ~# o9 \1 Z& d3 l) F
63.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    
64. 
    
65.     Features::StudioSplineBuilder *studioSplineBuilder1;
    2 m6 ]+ D1 g' {, c9 B
66.     studioSplineBuilder1 = workPart->Features()->
    # }( H3 U1 M1 _% Y+ I
67.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    
68.     studioSplineBuilder1->SetAssociative(true);
    ' N9 i  C1 f/ X  E! d
69.     studioSplineBuilder1->
    
70.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
    
71.     studioSplineBuilder1->
    
72.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
    % Y7 ]& m8 ~( f2 m" U" j1 e+ s
73.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    
74.     studioSplineBuilder1->SetPeriodic(false);
    9 s2 q; ?6 I. P
75.     studioSplineBuilder1->
    * x. S8 v0 _; q# L  @, p# Z. |6 [
76.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    
77.     std::vector<double> knots1(0);
    . ^0 L; C4 M1 a" n
78.     studioSplineBuilder1->SetKnots(knots1);
    
79.     std::vector<double> parameters1(0);
    - G0 ]( j: {5 N; F
80.     studioSplineBuilder1->SetParameters(parameters1);
    
81.     Direction *nullDirection(NULL);
    " B2 o. u) ]. t8 C* v3 i
82.     Scalar *nullScalar(NULL);
    / g9 B: K) @, Z* n1 N3 g: z7 Q
83.     Offset *nullOffset(NULL);
    
84. 
    " X$ l9 |4 O$ w% P( Z) F# C
85.     std::vector<Features::GeometricConstraintData *>
    * \2 W+ ^% d* O' E+ C" B8 y- W9 z
86.         geometricConstraintData(thePoints.size());
    ( V* S) S7 \- S! V: w* r
87. 
    . z1 v7 V1 {! [! W4 ^' t: u" A$ D: g
88.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    
89.     {
    9 I( B( g* Z  d1 g' X8 {
90.         geometricConstraintData[ii] = studioSplineBuilder1->
    
91.             ConstraintManager()->CreateGeometricConstraintData();
    & ?# A: b  r4 `# U- p( _  F" I
92.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    
93.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    # s4 d& Q: p/ E
94.             Features::GeometricConstraintData::ParameterDirectionIso);
    3 b/ Y) z8 }" ?% B8 G  J2 v! E. g
95.         geometricConstraintData[ii]->SetAutomaticConstraintType(
    # n, `  |+ L7 ?6 U- S9 D
96.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    
97.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    
98.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
    9 t" X$ U2 d$ n+ r
99.         geometricConstraintData[ii]->SetCurvature(nullOffset);
    $ Z1 s) K% Z  }+ j. j: h
100.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
     
101.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     5 m/ O& V8 o; Y
102.     }
     
103. 
     
104.     studioSplineBuilder1->ConstraintManager()->SetContents(
     
105.         geometricConstraintData);
     
106. 
     # E+ b% y7 ?) O: j0 j4 o; l: A
107.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     6 f9 E. V+ K8 F( c) @1 Y
108.     Spline *theSpline = studioSplineBuilder1->Curve();
     ) ~( q$ I7 F6 H& J9 q5 w2 W
109. 
     ! `/ z& t' T, T8 [+ l
110.     studioSplineBuilder1->Destroy();
     
111. 
     
112.     return theSpline;
     : I9 @: ?3 ^7 d0 w# M7 ?. P" w
113. }
     
114. 
     7 B( n  q2 I8 j' _/ m
115. extern "C" DllExport void ufusr(char *param, int *retcod, int param_len)
     2 L# |0 k. Q, m
116. {
     . n; U3 a9 `$ ~# {" j
117.     std::vector<Point *>thePoints = selectPoints("Studio Spline Thru Points");
     ( r" P- v7 Z+ b' o3 l/ K5 z" I6 ]
118.     if (!thePoints.size()) return;
     
119. 
     : K7 _- e* Z3 M/ @0 D! W6 A3 B
120.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     
121. 
     ( @# K; |5 Z1 D  H
122.     if (theSpline)
     
123.     {
     
124.         theSpline->Highlight();
     3 v4 {* D) e4 t' ~+ m: G+ E$ M
125.         uc1601("Studio Spline Created Thru Points", TRUE);
     9 o) F. Z/ j5 J
126.         theSpline->Unhighlight();
     
127.     }
     7 e& x% p) B% m! M
128. }
     

复制代码

: X8 w# h0 y# h0 k
# Z) t' a% F) E' D# f" b
$ |8 `0 ^0 A! e8 r% y