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

admin

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

1. #include <uf_defs.h>
   ( F% [$ t  p! k5 y* ?
2. #include <uf.h>
   
3. #include <uf_modl.h>
   
4. #include <uf_object_types.h>
   8 V, g6 r7 }* a( J
5. #include <uf_ui.h>
   ) P" z- s3 j0 b$ s$ L  [
6. #include <uf_modl.h>
   
7. #include <NXOpen/NXException.hxx>
   * L  _% z) w4 ~4 H
8. #include <NXOpen/Session.hxx>
   , S' K% G6 ?8 {
9. #include <NXOpen/Selection.hxx>
     A$ Z3 W/ s- b( f2 I0 Y
10. #include <NXOpen/Builder.hxx>
    
11. #include <NXOpen/Features_Feature.hxx>
    
12. #include <NXOpen/Features_FeatureBuilder.hxx>
    , r, N+ R  c8 p7 Q2 P+ y
13. #include <NXOpen/Features_FeatureCollection.hxx>
    3 A- J: H+ e% [
14. #include <NXOpen/Features_GeometricConstraintData.hxx>
    ( U' t% x2 C8 i# t' [5 [
15. #include <NXOpen/Features_GeometricConstraintDataManager.hxx>
    % a3 T' ^( h) H% k) x
16. #include <NXOpen/Features_StudioSplineBuilder.hxx>
    
17. #include <NXOpen/Part.hxx>
    # \& u; u3 [, _* |& i
18. #include <NXOpen/ParTCollection.hxx>
    : l8 {" I# g1 r; V. O) ^) Y' z6 M
19. #include <NXOpen/Point.hxx>
    
20. #include <NXOpen/PointCollection.hxx>
    ' t* W; P3 s* e! F. _( {5 {5 M
21. #include <NXOpen/NXString.hxx>
    - v7 r, B' F4 g5 i$ m( P& ^
22. #include <NXOpen/UI.hxx>
    
23. #include <NXOpen/Spline.hxx>
    5 Q( O. W/ |, y8 s
24. #include <NXOpen/NXObjectManager.hxx>
    7 R& t* [) ]+ }& w6 n3 ]
25. 
    
26. using namespace NXOpen;
    5 r0 V0 |) X6 z
27. using namespace std;
    $ P0 r6 o3 f& T+ v# w$ q1 o& f
28. 
    % X+ `% B* B& w7 A; W. Y/ t1 s7 C
29. extern "C" DllExport int ufusr_ask_unload()
    
30. {
    
31.     return (int)Session::LibraryUnloadOptionImmediately;
    / O) ]- M" J) \7 D/ P
32. }
    
33. 
    
34. static vector<Point *> selectPoints(NXString prompt)
    7 [9 I) G! i) l' H7 h
35. {
    , B' K/ M7 `2 `% T
36.     UI *ui = UI::GetUI();
    5 \9 e9 C7 V, |- l! u! s
37.     Selection *sm = ui->SelectionManager();
    
38.     std::vector<Selection::MaskTriple> mask(1);
    8 A+ u6 c: \1 ~* J, P
39.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
      D7 |$ r* D& Z
40.     std::vector<NXObject *> objects;
    . m4 j9 p& w% B7 W) O3 v5 A$ j9 E: o
41. 
    
42.     sm->SelectObjects("Select Points", prompt,
    
43.         Selection::SelectionScopeAnyInAssembly,
    1 q0 A3 D' R+ T9 A- ~3 d
44.         Selection::SelectionActionClearAndEnableSpecific,
    4 I# }, j3 M) m/ S2 Y- C2 A( m# u9 O
45.         false, false, mask, objects);
    
46. 
    
47.     vector<Point *>selPoints(objects.size());
    
48.     for (unsigned int ii = 0; ii < objects.size(); ii++)
    / t) t$ R) }$ s7 ~9 N- g. J! R
49.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    
50. 
    9 T" O. f. ~* z) {' C. A% ~: T
51.     return selPoints;
    + U8 o$ R! ~! ^- w: s- \8 Z9 A
52. }
    ; c; n' t' x; z
53. 
      l. w. d2 A' M" u* x; Z( q4 }
54. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    ' u. ~. I+ t* f1 q  S8 G1 ~9 E
55. {
      H* F1 W( p! ~4 w1 ]: Z& ~8 _
56.     Session *theSession = Session::GetSession();
    
57.     Part *workPart(theSession->Parts()->Work());
    
58. 
    
59.     Session::UndoMarkId markId1;
    
60.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    # S, Z& `- _) K/ K
61.         "Studio Spline Thru Points");
    $ K- r: A" z' @9 J" z# H- h9 ?! T6 X
62. 
    2 B4 N, e, H3 K/ m, e5 r
63.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    
64. 
    
65.     Features::StudioSplineBuilder *studioSplineBuilder1;
    
66.     studioSplineBuilder1 = workPart->Features()->
    4 [) `! {/ _0 ~, m9 L5 a% |  Y: _
67.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    ) W4 d& {6 J) u% A( _' @+ y, N8 V, I
68.     studioSplineBuilder1->SetAssociative(true);
    
69.     studioSplineBuilder1->
    * B  k) n2 k  Z& f: G& L2 w+ {/ P
70.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
    
71.     studioSplineBuilder1->
    0 H4 C- u! a8 h3 G
72.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
      T5 s+ P4 E  [$ J- _
73.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    ( y' X* M! {; K* T5 t* l; ?
74.     studioSplineBuilder1->SetPeriodic(false);
      q2 i* G% g* ~4 |# @
75.     studioSplineBuilder1->
    
76.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    
77.     std::vector<double> knots1(0);
    # L& W% a8 \& m1 u
78.     studioSplineBuilder1->SetKnots(knots1);
    $ C/ [) }" o$ h
79.     std::vector<double> parameters1(0);
    : n0 W1 w8 M1 F9 t7 |
80.     studioSplineBuilder1->SetParameters(parameters1);
    . s* s! [* F- J; G# t& M
81.     Direction *nullDirection(NULL);
    
82.     Scalar *nullScalar(NULL);
    # G0 ?% I, h" ~5 m8 A$ P. s4 I
83.     Offset *nullOffset(NULL);
    4 h, `9 m7 O* Z+ L$ L( E
84. 
    3 D! z1 C% t  c9 v' R0 J: i4 k, @
85.     std::vector<Features::GeometricConstraintData *>
      u# |0 A: w0 C2 d. t  a  {
86.         geometricConstraintData(thePoints.size());
    : e1 d* T1 o% f  u. i+ m
87. 
    1 z+ D+ |  I2 }, }7 T) g
88.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    ; l8 W( O" \$ g2 j
89.     {
    9 e$ w5 R. y7 K* _) Q
90.         geometricConstraintData[ii] = studioSplineBuilder1->
    - u5 m( x/ J2 c( u) v8 i, h( S
91.             ConstraintManager()->CreateGeometricConstraintData();
    
92.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    
93.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    ! j+ E, o$ U9 N4 B4 `$ R
94.             Features::GeometricConstraintData::ParameterDirectionIso);
    & @7 w# m2 ]1 y1 G/ U( k0 u' _
95.         geometricConstraintData[ii]->SetAutomaticConstraintType(
    3 }$ i" w; s1 D. I7 P2 P- `! z3 ?
96.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    ! [8 F4 r  A3 m' E, R1 G/ Q, F/ J
97.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    
98.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
    1 L' p/ ?& g5 h
99.         geometricConstraintData[ii]->SetCurvature(nullOffset);
      z1 \4 A" {% A$ N! V
100.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
     5 H4 U5 T  b% @3 {' j
101.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     ' T" w1 ^$ n/ W2 Z3 t  f) b0 l
102.     }
     3 a+ }, T$ w7 F9 e/ s
103. 
       ~; E: Q- b3 W) b1 e. _3 [4 S
104.     studioSplineBuilder1->ConstraintManager()->SetContents(
     % R# ~8 J; R1 }. u/ ?( B
105.         geometricConstraintData);
     
106. 
     
107.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     & Z# H+ ?# n" T; E
108.     Spline *theSpline = studioSplineBuilder1->Curve();
     
109. 
     " F* M* p$ ^% b
110.     studioSplineBuilder1->Destroy();
     
111. 
     ( p$ t9 |) X4 _
112.     return theSpline;
     8 W4 A9 }2 d% ]+ |4 P
113. }
     7 r1 ?) }0 e- u4 G# K7 j6 R
114. 
     
115. extern "C" DllExport void ufusr(char *param, int *retcod, int param_len)
     $ J+ Z) ]' w1 x6 {  M
116. {
     
117.     std::vector<Point *>thePoints = selectPoints("Studio Spline Thru Points");
     
118.     if (!thePoints.size()) return;
     
119. 
     
120.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     
121. 
     
122.     if (theSpline)
     
123.     {
     ( C5 O' J& e9 x! x+ p, d# V! T
124.         theSpline->Highlight();
     
125.         uc1601("Studio Spline Created Thru Points", TRUE);
     0 U0 [. r, b" m( V% L+ w6 I
126.         theSpline->Unhighlight();
     
127.     }
     , g; j/ }7 ^( M; j' ~3 X; x& a, p
128. }
     

复制代码

" v1 A% I+ \$ F! V& J* T. r9 E- \' ^
8 ~8 x* O2 u& ~9 {