0023024: Update headers of OCCT files
[occt.git] / src / GeometryTest / GeometryTest_FairCurveCommands.cxx
1 // Created on: 1996-10-09
2 // Created by: Philippe MANGIN
3 // Copyright (c) 1996-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
5 //
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
10 //
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 //
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
20
21
22
23 #include <GeometryTest.ixx>
24
25 #include <Draw.hxx>
26 #include <DrawTrSurf.hxx>
27 #include <DrawTrSurf_Point.hxx>
28 #include <gp_Pnt2d.hxx>
29 #include <FairCurve_AnalysisCode.hxx>
30 #include <FairCurve_Batten.hxx>
31 #include <FairCurve_MinimalVariation.hxx>
32 #include <DrawFairCurve_Batten.hxx>
33 #include <DrawFairCurve_MinimalVariation.hxx>
34 #include <string.h>
35
36 //=======================================================================
37 Standard_Boolean IsGoodNumber(Standard_Integer argc, Standard_Integer waiting, Draw_Interpretor& di)
38 //=======================================================================
39 {
40   // argc vaut 1 de plus, puisque argv[0] contient le nom de la commande
41   if (argc != (waiting+1))
42     {
43       di << "Waiting "<< waiting << " arguments" << "\n";
44       return Standard_False;
45     }
46   else
47     return Standard_True;
48 }
49
50
51 //=======================================================================
52 static Standard_Integer 
53 BattenCurve(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
54 //=======================================================================
55 {
56    if (!IsGoodNumber(argc,6,di)) return 1;
57
58   const char *cp1 = argv[1];
59   const char *cp2 = argv[2];
60   const char *cangle1 = argv[3];
61   const char *cangle2 = argv[4];
62   const char *cheigth = argv[5];
63   const char *BattenName = argv[6];
64
65   Standard_Boolean Ok;
66   FairCurve_AnalysisCode Iana;
67   Standard_Real a1 = atof(cangle1),
68                 a2 = atof(cangle2),
69                 h  = atof(cheigth);
70   gp_Pnt2d P1, P2;
71
72
73   if (! DrawTrSurf::GetPoint2d(cp1, P1) ) return 1;
74   if (! DrawTrSurf::GetPoint2d(cp2, P2) ) return 1;
75
76   FairCurve_Batten* Bat = new FairCurve_Batten (P1, P2, h);
77   Bat->SetAngle1(a1*M_PI/180);
78   Bat->SetAngle2(a2*M_PI/180);
79   
80   Ok = Bat->Compute(Iana);
81   
82   Handle(DrawFairCurve_Batten) aBatten = new DrawFairCurve_Batten(Bat);
83
84   if (aBatten.IsNull()) {
85         di << " Batten null "<< "\n";
86         return 1;
87       }
88   Draw::Set(BattenName,aBatten);
89
90   return 0;
91  // !!! Delete of Bat have to be make in DrawFairCurve_Batten destructor !!!!! 
92 }  
93
94
95 //=======================================================================
96 static Standard_Integer 
97 MVCurve(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
98 //=======================================================================
99 {
100    if (!IsGoodNumber(argc,6,di)) return 1;
101
102   const char *cp1 = argv[1];
103   const char *cp2 = argv[2];
104   const char *cangle1 = argv[3];
105   const char *cangle2 = argv[4];
106   const char *cheigth = argv[5];
107   const char *MVCName = argv[6];
108
109   Standard_Boolean Ok;
110   FairCurve_AnalysisCode Iana;
111   Standard_Real a1 = atof(cangle1),
112                 a2 = atof(cangle2),
113                 h  = atof(cheigth);
114   gp_Pnt2d P1, P2;
115
116
117   if (! DrawTrSurf::GetPoint2d(cp1, P1) ) return 1;
118   if (! DrawTrSurf::GetPoint2d(cp2, P2) ) return 1;
119
120   FairCurve_MinimalVariation* MVC = new  FairCurve_MinimalVariation (P1, P2, h);
121   MVC->SetAngle1(a1*M_PI/180);
122   MVC->SetAngle2(a2*M_PI/180);
123   
124   Ok = MVC->Compute(Iana);
125   
126   Handle(DrawFairCurve_MinimalVariation) aMVC = new DrawFairCurve_MinimalVariation(MVC);
127
128   if (aMVC.IsNull()) {
129         di << " MVC null "<< "\n";
130         return 1;
131       }
132   Draw::Set(MVCName, aMVC);
133
134   return 0;  
135  // !!! Delete of Bat have to be make in DrawFairCurve_MinimalVariation destructor !!!!! 
136 }  
137
138 //=======================================================================
139 static Standard_Integer 
140 SetPoint(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
141 //=======================================================================
142 {
143    if (!IsGoodNumber(argc,3,di)) return 1;
144
145   const char *side = argv[1];
146   const char *PointName = argv[2];
147   const char *BattenName = argv[3];
148
149   Standard_Integer cote = atoi(side);
150
151   Handle(DrawTrSurf_Point)
152      Pnt =  Handle(DrawTrSurf_Point)::DownCast(Draw::Get(PointName));
153   if (Pnt.IsNull()) return 1;  
154  
155  
156   Handle(DrawFairCurve_Batten) 
157     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
158   if (Bat.IsNull()) return 1;  
159  
160   Bat->SetPoint(cote, Pnt->Point2d());
161   Draw::Repaint();
162   return 0;
163 }
164
165 //=======================================================================
166 static Standard_Integer 
167 SetAngle(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
168 //=======================================================================
169 {
170    if (!IsGoodNumber(argc,3,di)) return 1;
171
172   const char *side = argv[1];
173   const char *val = argv[2];
174   const char *BattenName = argv[3];
175
176   Standard_Real angle = atof(val); 
177   Standard_Integer cote = atoi(side);
178  
179   Handle(DrawFairCurve_Batten) 
180     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
181   if (Bat.IsNull()) return 1;  
182  
183   Bat->SetAngle(cote, angle);
184   Draw::Repaint();
185   return 0;
186 }
187
188
189 //=======================================================================
190 static Standard_Integer 
191 SetCurvature(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
192 //=======================================================================
193 {
194    if (!IsGoodNumber(argc,3,di)) return 1;
195
196   const char *side = argv[1];
197   const char *val = argv[2];
198   const char *MVCName = argv[3];
199
200   Standard_Real rho = atof(val); 
201   Standard_Integer cote = atoi(side);
202  
203   Handle(DrawFairCurve_MinimalVariation) 
204     MVC = Handle(DrawFairCurve_MinimalVariation)::DownCast(Draw::Get(MVCName));
205   if (MVC.IsNull()) return 1;  
206  
207   MVC->SetCurvature(cote, rho);
208   Draw::Repaint(); 
209   return 0;
210 }
211
212
213
214 //=======================================================================
215 static Standard_Integer 
216 SetSlide(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
217 //=======================================================================
218 {
219    if (!IsGoodNumber(argc,2,di)) return 1;
220
221   const char *val = argv[1];
222   const char *BattenName = argv[2];
223
224   Standard_Real slide = atof(val); 
225  
226   Handle(DrawFairCurve_Batten) 
227     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
228   if (Bat.IsNull()) return 1;  
229
230   Bat->SetSliding(slide);
231   Draw::Repaint();
232   return 0;
233 }
234
235
236 //=======================================================================
237 static Standard_Integer 
238 FreeAngle(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
239 //=======================================================================
240 {
241    if (!IsGoodNumber(argc,2,di)) return 1;
242
243   const char *side = argv[1];
244   const char *BattenName = argv[2];
245  
246   Standard_Integer cote = atoi(side);
247  
248   Handle(DrawFairCurve_Batten) 
249     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
250   if (Bat.IsNull()) return 1;  
251  
252   Bat->FreeAngle(cote);
253   Draw::Repaint();
254   return 0;
255 }
256
257 //=======================================================================
258 static Standard_Integer 
259 FreeCurvature(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
260 //=======================================================================
261 {
262    if (!IsGoodNumber(argc,2,di)) return 1;
263
264   const char *side = argv[1];
265   const char *MVCName = argv[2];
266  
267   Standard_Integer cote = atoi(side);
268  
269   Handle(DrawFairCurve_MinimalVariation) 
270     MVC = Handle(DrawFairCurve_MinimalVariation)::DownCast(Draw::Get(MVCName));
271   if (MVC.IsNull()) return 1;  
272  
273   MVC->FreeCurvature(cote);
274   Draw::Repaint();
275   return 0;
276 }
277
278 //=======================================================================
279 static Standard_Integer 
280 FreeSlide(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
281 //=======================================================================
282 {
283    if (!IsGoodNumber(argc,1,di)) return 1;
284
285   const char *BattenName = argv[1];
286  
287   Handle(DrawFairCurve_Batten) 
288     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
289   if (Bat.IsNull()) return 1;  
290  
291   Bat->FreeSliding();
292   Draw::Repaint();
293   return 0;
294 }
295
296 //=======================================================================
297 static Standard_Integer 
298 SetHeight(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
299 //=======================================================================
300 {
301    if (!IsGoodNumber(argc,2,di)) return 1;
302
303   const char *val = argv[1];
304   const char *BattenName = argv[2];
305
306   Standard_Real Height = atof(val); 
307  
308   Handle(DrawFairCurve_Batten) 
309     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
310   if (Bat.IsNull()) return 1;  
311  
312   Bat->SetHeight(Height);
313   Draw::Repaint();
314   return 0;
315 }
316
317 //=======================================================================
318 static Standard_Integer 
319 SetSlope(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
320 //=======================================================================
321 {
322    if (!IsGoodNumber(argc,2,di)) return 1;
323
324   const char *val = argv[1];
325   const char *BattenName = argv[2];
326
327   Standard_Real Slope = atof(val); 
328  
329   Handle(DrawFairCurve_Batten) 
330     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
331   if (Bat.IsNull()) return 1;  
332  
333   Bat->SetSlope(Slope);
334   Draw::Repaint();
335   return 0;
336 }
337 //=======================================================================
338 static Standard_Integer 
339 SetPhysicalRatio(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
340 //=======================================================================
341 {
342    if (!IsGoodNumber(argc,2,di)) return 1;
343
344   const char *val = argv[1];
345   const char *MVCName = argv[2];
346
347   Standard_Real ratio = atof(val); 
348  
349   Handle(DrawFairCurve_MinimalVariation) 
350       MVC = Handle(DrawFairCurve_MinimalVariation)::DownCast(Draw::Get(MVCName));
351   if (MVC.IsNull()) return 1;  
352  
353   MVC->SetPhysicalRatio(ratio);
354   Draw::Repaint();
355   return 0;
356 }
357
358
359 //=======================================================================
360 void GeometryTest::FairCurveCommands(Draw_Interpretor& TheCommande) 
361 //=======================================================================
362
363
364   const char* g;
365
366   g = "FairCurve command";
367   
368   TheCommande.Add("battencurve","battencurve P1 P2 Angle1 Angle2 Heigth BattenName", 
369                    __FILE__,BattenCurve, g);
370   TheCommande.Add("minvarcurve","MVCurve P1 P2 Angle1 Angle2 Heigth MVCName", 
371                    __FILE__,MVCurve, g);
372   TheCommande.Add("setpoint","setpoint side point BattenName ",__FILE__, SetPoint, g);
373   TheCommande.Add("setangle","setangle side angle BattenName ",__FILE__, SetAngle, g);
374   TheCommande.Add("setslide","setangle slidingfactor BattenName ",__FILE__, SetSlide, g);
375   TheCommande.Add("freeangle","freeangle side BattenName",__FILE__, FreeAngle, g);
376   TheCommande.Add("freeslide","freeslide BattenName",__FILE__, FreeSlide, g);
377   TheCommande.Add("setheight","setheight height BattenName ",__FILE__, SetHeight, g);
378   TheCommande.Add("setslope","setslope slope BattenName ",__FILE__, SetSlope, g);
379   TheCommande.Add("setcurvature","setcurvature side rho MVCName ",__FILE__, SetCurvature, g);
380   TheCommande.Add("freecurvature","freecurvature side  MVCName ",__FILE__, FreeCurvature, g);
381   TheCommande.Add("setphysicalratio","physicalratio ratio MVCName ",__FILE__, SetPhysicalRatio, g);   
382 }