0024428: Implementation of LGPL license
[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-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and / or modify it
9 // under the terms of the GNU Lesser General Public version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <GeometryTest.ixx>
18
19 #include <Draw.hxx>
20 #include <DrawTrSurf.hxx>
21 #include <DrawTrSurf_Point.hxx>
22 #include <gp_Pnt2d.hxx>
23 #include <FairCurve_AnalysisCode.hxx>
24 #include <FairCurve_Batten.hxx>
25 #include <FairCurve_MinimalVariation.hxx>
26 #include <DrawFairCurve_Batten.hxx>
27 #include <DrawFairCurve_MinimalVariation.hxx>
28 #include <string.h>
29
30 //=======================================================================
31 Standard_Boolean IsGoodNumber(Standard_Integer argc, Standard_Integer waiting, Draw_Interpretor& di)
32 //=======================================================================
33 {
34   // argc vaut 1 de plus, puisque argv[0] contient le nom de la commande
35   if (argc != (waiting+1))
36     {
37       di << "Waiting "<< waiting << " arguments" << "\n";
38       return Standard_False;
39     }
40   else
41     return Standard_True;
42 }
43
44
45 //=======================================================================
46 static Standard_Integer 
47 BattenCurve(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
48 //=======================================================================
49 {
50    if (!IsGoodNumber(argc,6,di)) return 1;
51
52   const char *cp1 = argv[1];
53   const char *cp2 = argv[2];
54   const char *cangle1 = argv[3];
55   const char *cangle2 = argv[4];
56   const char *cheigth = argv[5];
57   const char *BattenName = argv[6];
58
59   Standard_Boolean Ok;
60   FairCurve_AnalysisCode Iana;
61   Standard_Real a1 = Draw::Atof(cangle1),
62                 a2 = Draw::Atof(cangle2),
63                 h  = Draw::Atof(cheigth);
64   gp_Pnt2d P1, P2;
65
66
67   if (! DrawTrSurf::GetPoint2d(cp1, P1) ) return 1;
68   if (! DrawTrSurf::GetPoint2d(cp2, P2) ) return 1;
69
70   FairCurve_Batten* Bat = new FairCurve_Batten (P1, P2, h);
71   Bat->SetAngle1(a1*M_PI/180);
72   Bat->SetAngle2(a2*M_PI/180);
73   
74   Ok = Bat->Compute(Iana);
75   
76   Handle(DrawFairCurve_Batten) aBatten = new DrawFairCurve_Batten(Bat);
77
78   if (aBatten.IsNull()) {
79         di << " Batten null "<< "\n";
80         return 1;
81       }
82   Draw::Set(BattenName,aBatten);
83
84   return 0;
85  // !!! Delete of Bat have to be make in DrawFairCurve_Batten destructor !!!!! 
86 }  
87
88
89 //=======================================================================
90 static Standard_Integer 
91 MVCurve(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
92 //=======================================================================
93 {
94    if (!IsGoodNumber(argc,6,di)) return 1;
95
96   const char *cp1 = argv[1];
97   const char *cp2 = argv[2];
98   const char *cangle1 = argv[3];
99   const char *cangle2 = argv[4];
100   const char *cheigth = argv[5];
101   const char *MVCName = argv[6];
102
103   Standard_Boolean Ok;
104   FairCurve_AnalysisCode Iana;
105   Standard_Real a1 = Draw::Atof(cangle1),
106                 a2 = Draw::Atof(cangle2),
107                 h  = Draw::Atof(cheigth);
108   gp_Pnt2d P1, P2;
109
110
111   if (! DrawTrSurf::GetPoint2d(cp1, P1) ) return 1;
112   if (! DrawTrSurf::GetPoint2d(cp2, P2) ) return 1;
113
114   FairCurve_MinimalVariation* MVC = new  FairCurve_MinimalVariation (P1, P2, h);
115   MVC->SetAngle1(a1*M_PI/180);
116   MVC->SetAngle2(a2*M_PI/180);
117   
118   Ok = MVC->Compute(Iana);
119   
120   Handle(DrawFairCurve_MinimalVariation) aMVC = new DrawFairCurve_MinimalVariation(MVC);
121
122   if (aMVC.IsNull()) {
123         di << " MVC null "<< "\n";
124         return 1;
125       }
126   Draw::Set(MVCName, aMVC);
127
128   return 0;  
129  // !!! Delete of Bat have to be make in DrawFairCurve_MinimalVariation destructor !!!!! 
130 }  
131
132 //=======================================================================
133 static Standard_Integer 
134 SetPoint(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
135 //=======================================================================
136 {
137    if (!IsGoodNumber(argc,3,di)) return 1;
138
139   const char *side = argv[1];
140   const char *PointName = argv[2];
141   const char *BattenName = argv[3];
142
143   Standard_Integer cote = Draw::Atoi(side);
144
145   Handle(DrawTrSurf_Point)
146      Pnt =  Handle(DrawTrSurf_Point)::DownCast(Draw::Get(PointName));
147   if (Pnt.IsNull()) return 1;  
148  
149  
150   Handle(DrawFairCurve_Batten) 
151     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
152   if (Bat.IsNull()) return 1;  
153  
154   Bat->SetPoint(cote, Pnt->Point2d());
155   Draw::Repaint();
156   return 0;
157 }
158
159 //=======================================================================
160 static Standard_Integer 
161 SetAngle(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
162 //=======================================================================
163 {
164    if (!IsGoodNumber(argc,3,di)) return 1;
165
166   const char *side = argv[1];
167   const char *val = argv[2];
168   const char *BattenName = argv[3];
169
170   Standard_Real angle = Draw::Atof(val); 
171   Standard_Integer cote = Draw::Atoi(side);
172  
173   Handle(DrawFairCurve_Batten) 
174     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
175   if (Bat.IsNull()) return 1;  
176  
177   Bat->SetAngle(cote, angle);
178   Draw::Repaint();
179   return 0;
180 }
181
182
183 //=======================================================================
184 static Standard_Integer 
185 SetCurvature(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
186 //=======================================================================
187 {
188    if (!IsGoodNumber(argc,3,di)) return 1;
189
190   const char *side = argv[1];
191   const char *val = argv[2];
192   const char *MVCName = argv[3];
193
194   Standard_Real rho = Draw::Atof(val); 
195   Standard_Integer cote = Draw::Atoi(side);
196  
197   Handle(DrawFairCurve_MinimalVariation) 
198     MVC = Handle(DrawFairCurve_MinimalVariation)::DownCast(Draw::Get(MVCName));
199   if (MVC.IsNull()) return 1;  
200  
201   MVC->SetCurvature(cote, rho);
202   Draw::Repaint(); 
203   return 0;
204 }
205
206
207
208 //=======================================================================
209 static Standard_Integer 
210 SetSlide(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
211 //=======================================================================
212 {
213    if (!IsGoodNumber(argc,2,di)) return 1;
214
215   const char *val = argv[1];
216   const char *BattenName = argv[2];
217
218   Standard_Real slide = Draw::Atof(val); 
219  
220   Handle(DrawFairCurve_Batten) 
221     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
222   if (Bat.IsNull()) return 1;  
223
224   Bat->SetSliding(slide);
225   Draw::Repaint();
226   return 0;
227 }
228
229
230 //=======================================================================
231 static Standard_Integer 
232 FreeAngle(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
233 //=======================================================================
234 {
235    if (!IsGoodNumber(argc,2,di)) return 1;
236
237   const char *side = argv[1];
238   const char *BattenName = argv[2];
239  
240   Standard_Integer cote = Draw::Atoi(side);
241  
242   Handle(DrawFairCurve_Batten) 
243     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
244   if (Bat.IsNull()) return 1;  
245  
246   Bat->FreeAngle(cote);
247   Draw::Repaint();
248   return 0;
249 }
250
251 //=======================================================================
252 static Standard_Integer 
253 FreeCurvature(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
254 //=======================================================================
255 {
256    if (!IsGoodNumber(argc,2,di)) return 1;
257
258   const char *side = argv[1];
259   const char *MVCName = argv[2];
260  
261   Standard_Integer cote = Draw::Atoi(side);
262  
263   Handle(DrawFairCurve_MinimalVariation) 
264     MVC = Handle(DrawFairCurve_MinimalVariation)::DownCast(Draw::Get(MVCName));
265   if (MVC.IsNull()) return 1;  
266  
267   MVC->FreeCurvature(cote);
268   Draw::Repaint();
269   return 0;
270 }
271
272 //=======================================================================
273 static Standard_Integer 
274 FreeSlide(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
275 //=======================================================================
276 {
277    if (!IsGoodNumber(argc,1,di)) return 1;
278
279   const char *BattenName = argv[1];
280  
281   Handle(DrawFairCurve_Batten) 
282     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
283   if (Bat.IsNull()) return 1;  
284  
285   Bat->FreeSliding();
286   Draw::Repaint();
287   return 0;
288 }
289
290 //=======================================================================
291 static Standard_Integer 
292 SetHeight(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
293 //=======================================================================
294 {
295    if (!IsGoodNumber(argc,2,di)) return 1;
296
297   const char *val = argv[1];
298   const char *BattenName = argv[2];
299
300   Standard_Real Height = Draw::Atof(val); 
301  
302   Handle(DrawFairCurve_Batten) 
303     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
304   if (Bat.IsNull()) return 1;  
305  
306   Bat->SetHeight(Height);
307   Draw::Repaint();
308   return 0;
309 }
310
311 //=======================================================================
312 static Standard_Integer 
313 SetSlope(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
314 //=======================================================================
315 {
316    if (!IsGoodNumber(argc,2,di)) return 1;
317
318   const char *val = argv[1];
319   const char *BattenName = argv[2];
320
321   Standard_Real Slope = Draw::Atof(val); 
322  
323   Handle(DrawFairCurve_Batten) 
324     Bat = Handle(DrawFairCurve_Batten)::DownCast(Draw::Get(BattenName));
325   if (Bat.IsNull()) return 1;  
326  
327   Bat->SetSlope(Slope);
328   Draw::Repaint();
329   return 0;
330 }
331 //=======================================================================
332 static Standard_Integer 
333 SetPhysicalRatio(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
334 //=======================================================================
335 {
336    if (!IsGoodNumber(argc,2,di)) return 1;
337
338   const char *val = argv[1];
339   const char *MVCName = argv[2];
340
341   Standard_Real ratio = Draw::Atof(val); 
342  
343   Handle(DrawFairCurve_MinimalVariation) 
344       MVC = Handle(DrawFairCurve_MinimalVariation)::DownCast(Draw::Get(MVCName));
345   if (MVC.IsNull()) return 1;  
346  
347   MVC->SetPhysicalRatio(ratio);
348   Draw::Repaint();
349   return 0;
350 }
351
352
353 //=======================================================================
354 void GeometryTest::FairCurveCommands(Draw_Interpretor& TheCommande) 
355 //=======================================================================
356
357
358   const char* g;
359
360   g = "FairCurve command";
361   
362   TheCommande.Add("battencurve","battencurve P1 P2 Angle1 Angle2 Heigth BattenName", 
363                    __FILE__,BattenCurve, g);
364   TheCommande.Add("minvarcurve","MVCurve P1 P2 Angle1 Angle2 Heigth MVCName", 
365                    __FILE__,MVCurve, g);
366   TheCommande.Add("setpoint","setpoint side point BattenName ",__FILE__, SetPoint, g);
367   TheCommande.Add("setangle","setangle side angle BattenName ",__FILE__, SetAngle, g);
368   TheCommande.Add("setslide","setangle slidingfactor BattenName ",__FILE__, SetSlide, g);
369   TheCommande.Add("freeangle","freeangle side BattenName",__FILE__, FreeAngle, g);
370   TheCommande.Add("freeslide","freeslide BattenName",__FILE__, FreeSlide, g);
371   TheCommande.Add("setheight","setheight height BattenName ",__FILE__, SetHeight, g);
372   TheCommande.Add("setslope","setslope slope BattenName ",__FILE__, SetSlope, g);
373   TheCommande.Add("setcurvature","setcurvature side rho MVCName ",__FILE__, SetCurvature, g);
374   TheCommande.Add("freecurvature","freecurvature side  MVCName ",__FILE__, FreeCurvature, g);
375   TheCommande.Add("setphysicalratio","physicalratio ratio MVCName ",__FILE__, SetPhysicalRatio, g);   
376 }