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

admin

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

1. #include <uf_defs.h>
   
2. #include <uf.h>
   
3. #include <uf_modl.h>
   ) p4 I% I' O2 x3 v4 x
4. #include <uf_object_types.h>
   % \" L; P6 E4 |! {* B2 s  u. G$ \
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>
      p# M0 ?# o! I4 g# Q# q- D
12. #include <NXOpen/Features_FeatureBuilder.hxx>
    6 s) A! E$ g; q0 l0 z" P+ d* a
13. #include <NXOpen/Features_FeatureCollection.hxx>
    ; b5 f( z* A* y& ], R* E( n3 C
14. #include <NXOpen/Features_GeometricConstraintData.hxx>
    ! G) w9 I$ n3 y+ ]; J, O' o
15. #include <NXOpen/Features_GeometricConstraintDataManager.hxx>
    
16. #include <NXOpen/Features_StudioSplineBuilder.hxx>
    
17. #include <NXOpen/Part.hxx>
    & u4 |* I; q: e) Q' Z) }# D! i
18. #include <NXOpen/ParTCollection.hxx>
    
19. #include <NXOpen/Point.hxx>
    
20. #include <NXOpen/PointCollection.hxx>
    
21. #include <NXOpen/NXString.hxx>
    
22. #include <NXOpen/UI.hxx>
    
23. #include <NXOpen/Spline.hxx>
    
24. #include <NXOpen/NXObjectManager.hxx>
    
25. 
    - r7 V  m  k# N; i! r
26. using namespace NXOpen;
    
27. using namespace std;
    
28. 
    
29. extern "C" DllExport int ufusr_ask_unload()
    
30. {
    
31.     return (int)Session::LibraryUnloadOptionImmediately;
    
32. }
    3 A% S5 q, |; ?7 Z/ S  a
33. 
    
34. static vector<Point *> selectPoints(NXString prompt)
    
35. {
    8 ?3 N; y6 D( r3 U6 O, e( ]$ N
36.     UI *ui = UI::GetUI();
    
37.     Selection *sm = ui->SelectionManager();
    # ]) q7 U/ a: u+ p
38.     std::vector<Selection::MaskTriple> mask(1);
    
39.     mask[0] = Selection::MaskTriple(UF_point_type, 0, 0);
    , e' m* B+ f4 N
40.     std::vector<NXObject *> objects;
    ( n( {6 J* I; G/ y
41. 
    
42.     sm->SelectObjects("Select Points", prompt,
    
43.         Selection::SelectionScopeAnyInAssembly,
    
44.         Selection::SelectionActionClearAndEnableSpecific,
    
45.         false, false, mask, objects);
    
46. 
    + }( ?$ O2 W! U! [
47.     vector<Point *>selPoints(objects.size());
    8 E# Q5 y" s' V/ v) V6 k0 S
48.     for (unsigned int ii = 0; ii < objects.size(); ii++)
    
49.         selPoints[ii] = dynamic_cast<Point *>(objects[ii]);
    9 x1 P( m7 L: q* g3 G5 p+ r7 T- A
50. 
    
51.     return selPoints;
    & A% z$ }% y) x& s3 G  D
52. }
    5 ?7 f* U/ w( a: t/ Z: N+ ^: y# j6 P
53. 
    ; I, }7 \. Q: ^4 |
54. static Spline *createStudioSplineThruPoints(vector<Point *> thePoints)
    " z5 w2 i6 q2 O4 ^4 Y. P
55. {
    2 M8 [3 o2 ]4 Q6 l
56.     Session *theSession = Session::GetSession();
    
57.     Part *workPart(theSession->Parts()->Work());
    ! S. g; g- E3 n" j+ P
58. 
    . D8 X9 p% A/ {5 _; {
59.     Session::UndoMarkId markId1;
    
60.     markId1 = theSession->SetUndoMark(Session::MarkVisibilityVisible,
    
61.         "Studio Spline Thru Points");
    5 b, c: `1 I; U) t% B9 D& s& K3 ?" Q
62. 
    1 _( U: ^' t  `# m& f
63.     Features::StudioSpline *nullFeatures_StudioSpline(NULL);
    
64. 
    
65.     Features::StudioSplineBuilder *studioSplineBuilder1;
    3 _; n7 W) ?# K( v
66.     studioSplineBuilder1 = workPart->Features()->
    
67.         CreateStudioSplineBuilder(nullFeatures_StudioSpline);
    % i% Z% [& ]: E" o' ~$ o
68.     studioSplineBuilder1->SetAssociative(true);
    
69.     studioSplineBuilder1->
    
70.         SetInputCurveOption(Features::StudioSplineBuilder::CurveOptionRetain);
    0 T4 B! k2 n# ^& |  q
71.     studioSplineBuilder1->
    0 [; c! h7 @/ r9 Z' p
72.         SetSplineMethod(Features::StudioSplineBuilder::MethodThroUGhPoints);
    
73.     studioSplineBuilder1->SetDegree((int)thePoints.size() - 1);
    
74.     studioSplineBuilder1->SetPeriodic(false);
    
75.     studioSplineBuilder1->
    9 M% b6 q- ~8 X. V) ]5 n( y. i/ z+ m
76.         SetMatchKnots(Features::StudioSplineBuilder::MatchKnotsTypeNone);
    
77.     std::vector<double> knots1(0);
    
78.     studioSplineBuilder1->SetKnots(knots1);
    & n+ q) p8 J5 [+ S1 c$ Q
79.     std::vector<double> parameters1(0);
    7 g1 S+ @6 n, z% W. B- O: R! b* ^
80.     studioSplineBuilder1->SetParameters(parameters1);
    
81.     Direction *nullDirection(NULL);
    
82.     Scalar *nullScalar(NULL);
    
83.     Offset *nullOffset(NULL);
    5 {( V0 T( U& v6 c0 J* O5 m) x
84. 
    
85.     std::vector<Features::GeometricConstraintData *>
    * U! ?2 p; a. Z8 r4 [/ P9 |6 h8 c
86.         geometricConstraintData(thePoints.size());
    
87. 
    + c  c+ G  T( P& ^) u9 b
88.     for (unsigned int ii = 0; ii < thePoints.size(); ii++)
    , v  M! P9 H" j, m6 ~1 n* s
89.     {
    5 B8 G. q* m0 O, D
90.         geometricConstraintData[ii] = studioSplineBuilder1->
    : `! i' h6 V( V& t8 Y( d" V5 ~3 r. \
91.             ConstraintManager()->CreateGeometricConstraintData();
    
92.         geometricConstraintData[ii]->SetPoint(thePoints[ii]);
    
93.         geometricConstraintData[ii]->SetAutomaticConstraintDirection(
    
94.             Features::GeometricConstraintData::ParameterDirectionIso);
    
95.         geometricConstraintData[ii]->SetAutomaticConstraintType(
    
96.             Features::GeometricConstraintData::AutoConstraintTypeNone);
    
97.         geometricConstraintData[ii]->SetTangentDirection(nullDirection);
    - h8 }6 M4 s+ I6 O7 j1 S
98.         geometricConstraintData[ii]->SetTangentMagnitude(nullScalar);
    5 V# |( g& x$ o% ?! o
99.         geometricConstraintData[ii]->SetCurvature(nullOffset);
    
100.         geometricConstraintData[ii]->SetCurvatureDerivative(nullOffset);
     
101.         geometricConstraintData[ii]->SetHasSymmetricModelingConstraint(false);
     2 q6 m6 ?; T- w0 l0 d; |- n% J  J
102.     }
     ' C/ |0 D3 t4 m
103. 
     
104.     studioSplineBuilder1->ConstraintManager()->SetContents(
     
105.         geometricConstraintData);
     
106. 
     
107.     Features::Feature *feature1 = studioSplineBuilder1->CommitFeature();
     
108.     Spline *theSpline = studioSplineBuilder1->Curve();
     5 E6 s3 R" L/ C' S' _
109. 
     
110.     studioSplineBuilder1->Destroy();
     7 ~  x) E: c" c3 J% W% c4 e
111. 
     " F1 h6 d& z8 `9 j7 X- t) e
112.     return theSpline;
     
113. }
     
114. 
     4 b! n0 X/ k" b3 ~9 y2 X6 y
115. extern "C" DllExport void ufusr(char *param, int *retcod, int param_len)
       k$ a% v$ T) q3 }- l3 ^+ r
116. {
     
117.     std::vector<Point *>thePoints = selectPoints("Studio Spline Thru Points");
     % I0 O* w3 L+ S8 ~6 E) B. K
118.     if (!thePoints.size()) return;
     * D! F9 Y! x9 W
119. 
     
120.     Spline *theSpline = createStudioSplineThruPoints(thePoints);
     
121. 
     2 `9 X) ~! W% z4 u# K% i* R+ l
122.     if (theSpline)
       n5 d- Q; v- |) ~
123.     {
     
124.         theSpline->Highlight();
     * b& `+ S' b  ]4 t
125.         uc1601("Studio Spline Created Thru Points", TRUE);
     5 {; k/ d) i  `2 f/ t' i( Y6 a. P; |3 n# f
126.         theSpline->Unhighlight();
     
127.     }
     # M% s$ p  A8 f2 A
128. }
     

复制代码