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

admin

NX二次开发源码： 通过点创建样条曲线
3 P/ Q3 w* G) d$ S; x% C

1. #include <uf_defs.h>
   4 z4 @6 Y( R( o
2. #include <uf.h>
   , f. A( i: H- |3 H
3. #include <uf_modl.h>
   
4. #include <uf_object_types.h>
   : L4 G% b$ l3 K0 k8 s
5. #include <uf_ui.h>
   
6. #include <uf_modl.h>
   
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>
    6 s1 X5 }% A; g2 I1 t* M3 S
13. #include <NXOpen/Features_FeatureCollection.hxx>
    # `( c( j  {2 G- ?" o
14. #include <NXOpen/Features_GeometricConstraintData.hxx>
    4 w2 E1 i6 L, d5 R  s
15. #include <NXOpen/Features_GeometricConstraintDataManager.hxx>
    
16. #include <NXOpen/Features_StudioSplineBuilder.hxx>
    + m/ n7 |6 ]4 a( ]' H& M
17. #include <NXOpen/Part.hxx>
    4 r  {5 z& b' f5 y
18. #include <NXOpen/ParTCollection.hxx>
    ( P8 O8 C/ J+ x5 y& S/ l( o
19. #include <NXOpen/Point.hxx>
    6 u" U! a  ]5 _
20. #include <NXOpen/PointCollection.hxx>
      _. I# f+ ?/ s
21. #include <NXOpen/NXString.hxx>
    8 U6 {5 n6 d/ A% F& \3 v3 j
22. #include <NXOpen/UI.hxx>
    
23. #include <NXOpen/Spline.hxx>
    ; J0 z" S" t4 |5 O7 X
24. #include <NXOpen/NXObjectManager.hxx>
    
25. 
    * E5 x  V1 s, q9 O6 J
26. using namespace NXOpen;
    # q; p0 N& m7 r
27. using namespace std;
    / r( w" Q* i. F# o2 |2 D
28. 
    
29. extern "C" DllExport int ufusr_ask_unload()
    $ [0 u# `) Y( }, J  Z' O+ z' Q' H9 A
30. {
    3 F$ f! @- [4 R; S- ^
31.     return (int)Session::LibraryUnloadOptionImmediately;
    $ j, Q2 m; m0 t) m% _' h# z0 U& K
32. }
    ! x: q8 l- R# I- s1 O
33. 
    
34. static vector<Point *> selectPoints(NXString prompt)
    5 u& l5 X. p' p. ~
35. {
    ! C" Q" X& G0 {% w) n
36.     UI *ui = UI::GetUI();
    ) s+ j! J7 x% b5 p$ v) s
37.     Selection *sm = ui->SelectionManager();
    
38.     std::vector<Selection::MaskTriple> mask(1);
    2 w. Q  f9 x5 ]- ~3 N8 G9 ]) z
39.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
    . z. T- _2 ]& |+ D  v  c$ A
40.     std::vector<NXObject *> objects;
    : D1 R0 U) z- y) U( D, m& I
41. 
    
42.     sm->SelectObjects("Select Points", prompt,
    
43.         Selection::SelectionScopeAnyInAssembly,
    
44.         Selection::SelectionActionClearAndEnableSpecific,
    
45.         false, false, mask, objects);
    3 T& K$ z' d$ J' {) G* Q# }
46. 
    
47.     vector<Point *>selPoints(objects.size());
    
48.     for (unsigned int ii = 0; ii < objects.size(); ii++)
    
49.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    
50. 
    
51.     return selPoints;
    2 U; H8 t! {& k' o$ d
52. }
    
53. 
      I* r; n) Z7 y' a: J
54. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    
55. {
    
56.     Session *theSession = Session::GetSession();
    
57.     Part *workPart(theSession->Parts()->Work());
    1 B, d( |' G) z' B& ?3 \
58. 
    
59.     Session::UndoMarkId markId1;
    
60.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    
61.         "Studio Spline Thru Points");
    
62. 
    ' q$ i  A* K# \% u3 G
63.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    / d3 S9 N) b7 v6 @
64. 
    ! T) t& @# y! H' q1 b, `  v
65.     Features::StudioSplineBuilder *studioSplineBuilder1;
    
66.     studioSplineBuilder1 = workPart->Features()->
    " P1 |0 D  T3 F* n7 ?
67.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    
68.     studioSplineBuilder1->SetAssociative(true);
    4 i" a- Y( f2 m5 i+ ^$ g
69.     studioSplineBuilder1->
    
70.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
    
71.     studioSplineBuilder1->
    1 R, R* z& ]) ~6 v. v
72.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
      ~5 a# D% t2 f% c5 w0 e9 x# q
73.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    2 X9 q9 M. M" c- s
74.     studioSplineBuilder1->SetPeriodic(false);
    - N+ d: V. R8 F+ R2 f  x
75.     studioSplineBuilder1->
    
76.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    
77.     std::vector<double> knots1(0);
    
78.     studioSplineBuilder1->SetKnots(knots1);
    " {, F) }  j& c4 s3 m9 [3 O
79.     std::vector<double> parameters1(0);
    9 P2 P* v; U) b+ z0 ~- \
80.     studioSplineBuilder1->SetParameters(parameters1);
    * d& |! b* V( Z1 H0 a
81.     Direction *nullDirection(NULL);
    # N$ |6 |0 y5 @* {1 a. V4 _1 x/ q
82.     Scalar *nullScalar(NULL);
    
83.     Offset *nullOffset(NULL);
    / B3 `# }% y- Y
84. 
    
85.     std::vector<Features::GeometricConstraintData *>
    
86.         geometricConstraintData(thePoints.size());
    
87. 
    
88.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    6 [6 F' Q8 p# V6 N+ `
89.     {
      C- f3 {4 U: ~% v5 i( F* G
90.         geometricConstraintData[ii] = studioSplineBuilder1->
    ! m& H+ r' s+ Y9 e5 C$ q+ u! T7 L8 [& H
91.             ConstraintManager()->CreateGeometricConstraintData();
    
92.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    / ^" i+ Z& o7 |
93.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    
94.             Features::GeometricConstraintData::ParameterDirectionIso);
    - z* W+ [1 y0 h! g
95.         geometricConstraintData[ii]->SetAutomaticConstraintType(
      T& G) ?. T/ b8 m
96.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    
97.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    
98.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
    
99.         geometricConstraintData[ii]->SetCurvature(nullOffset);
    9 c; Y! K& y5 Z$ G2 g* x, p
100.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
     
101.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     7 E4 [. L6 x  T3 @9 T+ P
102.     }
     9 K, {1 _) A- K0 u  e5 ?
103. 
     5 A' }( C  n1 ^# ]) c3 ~) U' q
104.     studioSplineBuilder1->ConstraintManager()->SetContents(
     - _$ O, P3 C* {7 Q9 u6 R# |
105.         geometricConstraintData);
     
106. 
     " D' v, O; s. u2 G" K2 ]
107.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     
108.     Spline *theSpline = studioSplineBuilder1->Curve();
     : C4 w" N/ G1 H+ \: g
109. 
     % f* C7 A) b+ D6 O4 P: Y
110.     studioSplineBuilder1->Destroy();
     
111. 
     
112.     return theSpline;
       {" Z- D1 m8 F3 ^
113. }
     1 b" R5 ]% Q# R$ ^) b; k
114. 
     ' V. A3 h7 F" c9 Z, G4 j" J3 Z# W  u
115. extern "C" DllExport void ufusr(char *param, int *retcod, int param_len)
     7 |; I: e7 J4 J) n
116. {
     ' d% @2 d. \2 \' G4 @- J2 U" v0 f
117.     std::vector<Point *>thePoints = selectPoints("Studio Spline Thru Points");
     & ?, v: p- n; _3 k  \+ ?! n& V, f! ^
118.     if (!thePoints.size()) return;
     , A2 ]* L7 o, E) m2 N/ D" K
119. 
     6 a0 |! I7 c3 `7 I) f0 c; U1 h5 b
120.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     
121. 
     ; T5 P; i. T) N9 l. F/ @4 t
122.     if (theSpline)
     - x" Q% V! \8 w% G. ~
123.     {
     2 L! D- X$ |8 R6 B4 w, B2 e% |/ Y, u
124.         theSpline->Highlight();
     
125.         uc1601("Studio Spline Created Thru Points", TRUE);
     
126.         theSpline->Unhighlight();
     
127.     }
     
128. }
     

复制代码

3 \. t$ W( c) k2 N( G* T2 |
. I# {. @0 Q5 l: D9 P
: C+ f9 v0 p- S" x% @% }! u+ ^