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

mildcat

NX二次开发源码：通过选择点创建样条曲线
) i% }9 U# M" a. t

  Q) |: T& V% i  X7 {

1. 
   ! o# g: R, w9 D) n% E* G- r; y0 E; A; t
2. #include <uf_defs.h>
   
3. #include <uf.h>
   
4. #include <uf_modl.h>
   # B; a. n8 v& A' G5 B  {
5. #include <uf_object_types.h>
   ! M/ v6 @$ C$ l: R$ q( F
6. #include <uf_ui.h>
   ; B4 P1 c3 J: T! f
7. #include <uf_modl.h>
   2 m  Z: e6 i. D
8. #include <<em>NXOpen</em>/NXException.hxx>
   9 J1 X' k2 D$ N, L! \
9. #include <<em>NXOpen</em>/Session.hxx>
   , Y  V% [$ N9 Y5 c5 A
10. #include <<em>NXOpen</em>/Selection.hxx>
      m, n5 _, F0 d3 s; C; b- h, L. T
11. #include <<em>NXOpen</em>/Builder.hxx>
    ) y$ u1 h; z2 r4 d; V3 R: \3 w
12. #include <<em>NXOpen</em>/Features_Feature.hxx>
    9 |& @1 ]6 L9 N% E# C# |- z' m
13. #include <<em>NXOpen</em>/Features_FeatureBuilder.hxx>
    " k9 Y2 z2 P2 w) y
14. #include <<em>NXOpen</em>/Features_FeatureCollection.hxx>
    
15. #include <<em>NXOpen</em>/Features_GeometricConstraintData.hxx>
    
16. #include <<em>NXOpen</em>/Features_GeometricConstraintDataManager.hxx>
    
17. #include <<em>NXOpen</em>/Features_StudioSplineBuilder.hxx>
    3 ]: O5 Q2 H5 g
18. #include <<em>NXOpen</em>/Part.hxx>
    
19. #include <<em>NXOpen</em>/ParTCollection.hxx>
    
20. #include <<em>NXOpen</em>/Point.hxx>
    
21. #include <<em>NXOpen</em>/PointCollection.hxx>
    
22. #include <<em>NXOpen</em>/NXString.hxx>
    - x$ i' Y5 v8 H" ~6 i9 g2 U  V+ U" n1 A
23. #include <<em>NXOpen</em>/UI.hxx>
    # B( f$ X* \5 a9 `; |8 v( v- n
24. #include <<em>NXOpen</em>/Spline.hxx>
    0 }. J  ?7 u( ^/ x
25. #include <<em>NXOpen</em>/NXObjectManager.hxx>
    
26. 
    ) a  O: f" k5 W/ v) Y
27. using namespace <em>NXOpen</em>;
    ( J8 b* o2 Z- ^
28. using namespace std;
    
29. 
      H7 U. c. g1 u( d: n+ H
30. extern "<em>C</em>" DllExport int ufusr_ask_unload()
    
31. {
    7 Q# Y5 G7 ?$ `; E4 L+ v2 m
32.     return (int)Session::LibraryUnloadOptionImmediately;
    
33. }
    
34. 
    
35. static vector<Point *> selectPoints(NXString prompt)
    . F# n/ J; X' S+ c' U& R; b
36. {
    5 l8 i$ \4 ^# A7 G; m* V
37.     UI *ui = UI::GetUI();
    * X' f- l* y8 v/ N( y, e
38.     Selection *sm = ui->SelectionManager();
    
39.     std::vector<Selection::MaskTriple> mask(1);
    ) {  z; `' V+ Y) [. U# g$ r
40.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
    
41.     std::vector<NXObject *> objects;
    
42. 
    
43.     sm->SelectObjects("Select Points", prompt,
      [" X4 X  G% ~3 m0 T4 a
44.         Selection::SelectionScopeAnyInAssembly,
    
45.         Selection::SelectionActionClearAndEnableSpecific,
    " n* g5 ^5 h; q! T$ G6 A! Y
46.         false, false, mask, objects);
    
47. 
    
48.     vector<Point *>selPoints(objects.size());
    
49.     for (unsigned int ii = 0; ii < objects.size(); ii++)
    
50.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    
51. 
    
52.     return selPoints;
    $ ?0 ?" |0 l1 S
53. }
    : B" d" z- f/ ^0 v; g
54. 
    
55. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    
56. {
    ) c8 a+ k! C, R! X% o: S/ o
57.     Session *theSession = Session::GetSession();
    * e! `  G% b/ c+ Y
58.     Part *workPart(theSession->Parts()->Work());
    * \$ t$ \2 z1 z2 {: J: D
59. 
    
60.     Session::UndoMarkId markId1;
    " L( ?$ F1 Y0 _. o4 Q
61.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    9 k+ F3 T" T4 e) F3 v
62.         "Studio Spline Thru Points");
    # {5 g* S$ `$ j4 E1 ~) t+ l5 j
63. 
    
64.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    
65. 
    * }& T3 L0 A" M& ]8 d  R- z
66.     Features::StudioSplineBuilder *studioSplineBuilder1;
    
67.     studioSplineBuilder1 = workPart->Features()->
    % V/ T, o' d/ j1 w6 C/ X
68.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    
69.     studioSplineBuilder1->SetAssociative(true);
    - Q# |+ K1 z! D% E' j
70.     studioSplineBuilder1->
    / _3 x5 Z+ q! z! q
71.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
    - X9 @" Z% p. }0 F' {
72.     studioSplineBuilder1->
    . P$ H# `$ }. q3 H2 d' T' u/ f
73.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
    3 }; F  U+ `' b9 N0 \$ O5 c
74.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    ; U. g4 z" Q- F
75.     studioSplineBuilder1->SetPeriodic(false);
    7 G' S+ }$ N& Y4 z( c
76.     studioSplineBuilder1->
    7 L. D. i5 x/ n' w/ A4 J  G5 t
77.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    6 p2 M/ p; s$ M* M/ U
78.     std::vector<double> knots1(0);
    
79.     studioSplineBuilder1->SetKnots(knots1);
    
80.     std::vector<double> parameters1(0);
    + v, O2 k% c" s; L3 p$ \: b' x
81.     studioSplineBuilder1->SetParameters(parameters1);
    
82.     Direction *nullDirection(NULL);
    " e2 M- ]* z0 _* j3 U/ x9 r) n" l
83.     Scalar *nullScalar(NULL);
    
84.     Offset *nullOffset(NULL);
    7 X- k- j0 C) T7 X! c, |/ ?1 w
85. 
    $ u4 Y( J$ G. I0 Z
86.     std::vector<Features::GeometricConstraintData *>
    ; Y4 u' Q3 c" H. b$ D( s7 |1 T" Q5 x
87.         geometricConstraintData(thePoints.size());
    5 K. J( W3 a5 U! l! S
88. 
    ' e$ {' `4 f6 f. F2 _0 D0 @
89.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    
90.     {
    
91.         geometricConstraintData[ii] = studioSplineBuilder1->
    9 j1 I3 R1 z5 A* z
92.             ConstraintManager()->CreateGeometricConstraintData();
      L6 I7 p- W$ Z* @2 j4 r
93.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    0 U/ m4 J  i) O% h0 F* Y2 u7 b+ Z
94.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    . e& E0 f5 B9 X
95.             Features::GeometricConstraintData::ParameterDirectionIso);
    1 k% R$ |; a: S
96.         geometricConstraintData[ii]->SetAutomaticConstraintType(
    
97.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    
98.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    
99.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
      M# d7 v5 P7 j4 h
100.         geometricConstraintData[ii]->SetCurvature(nullOffset);
     . Q$ A9 H+ ]% E1 ?+ v; G( h0 [7 x
101.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
     
102.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     3 r) n* z2 ^1 ]1 E# v' p$ x
103.     }
     
104. 
     % \6 {% ?9 r) s5 N1 e' ~) @
105.     studioSplineBuilder1->ConstraintManager()->SetContents(
     ) W. A. A3 w# a" _
106.         geometricConstraintData);
     
107. 
     9 `& e7 L4 L; Z$ M7 [
108.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     
109.     Spline *theSpline = studioSplineBuilder1-><em>Curve</em>();
     ( h# N. Y) i0 u3 j8 p' j, ~
110. 
     , J! q4 M# S7 n$ c5 P. ~  G, C1 s
111.     studioSplineBuilder1->Destroy();
       |3 {7 S4 w9 G, t: D
112. 
     . C+ v1 ]/ e4 r+ F
113.     return theSpline;
     0 k9 x+ I1 \: \, d8 r/ M$ k
114. }
     ! Y' B8 B" b% Y  S- C% q/ j1 D
115. 
     7 C7 S/ u, Y; W8 Z
116. extern "<em>C</em>" DllExport void ufusr(char *param, int *retcod, int param_len)
     
117. {
     
118.     std::vector<Point *>thePoints = selectPoints("Studio Spline Thru Points");
     
119.     if (!thePoints.size()) return;
     . l6 C' @: _$ z; a# a& e
120. 
     
121.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     
122. 
     . r/ d+ P, _& @0 N; i$ G& G3 P' |
123.     if (theSpline)
     / ~5 g0 T8 q4 A& P% k+ A& H- X
124.     {
     & b( Q0 `# |/ c  S" h: t
125.         theSpline->Highlight();
     
126.         uc1601("Studio Spline Created Thru Points", TRUE);
     : s7 d3 |: S$ Q  b! B- `5 @8 f; f
127.         theSpline->Unhighlight();
     
128.     }
     0 J0 H7 w, N7 y$ Z
129. }
     3 B$ Z4 g5 Q+ i6 I
130. <p> </p>

复制代码