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 = Draw::Atof(cangle1),
  68                 a2 = Draw::Atof(cangle2),
  69                 h  = Draw::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 = Draw::Atof(cangle1),
 112                 a2 = Draw::Atof(cangle2),
 113                 h  = Draw::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 = Draw::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 = Draw::Atof(val);
 177   Standard_Integer cote = Draw::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 = Draw::Atof(val);
 201   Standard_Integer cote = Draw::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 = Draw::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 = Draw::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 = Draw::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 = Draw::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 = Draw::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 = Draw::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 }