src/GeometryTest/GeometryTest_ContinuityCommands.cxx

   1 // Created on: 1996-07-31
   2 // Created by: Herve LOUESSARD
   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 under
   9 // the terms of the GNU Lesser General Public License 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 <LocalAnalysis.hxx>
  18 #include <LocalAnalysis_SurfaceContinuity.hxx>
  19 #include <LocalAnalysis_CurveContinuity.hxx>
  20 #include <Geom_Surface.hxx>
  21 #include <Geom_Curve.hxx>
  22 #include <Geom2d_TrimmedCurve.hxx>
  23 #include <Geom2d_Curve.hxx>
  24 #include <DrawTrSurf.hxx>
  25 #include <GeometryTest.hxx>
  26 #include <GeomAbs_Shape.hxx>
  27 #include <Draw_Appli.hxx>
  28 #include <Draw.hxx>
  29 #include <Draw_Interpretor.hxx>
  30
  31 /*********************************************************************************/
  32 void  InitEpsSurf(Standard_Real& epsnl,Standard_Real& epsdis, Standard_Real& epsangk1,
  33                                Standard_Real& epsangk2, Standard_Real& epsangn1,
  34                                Standard_Real& perce,Standard_Real& maxlen )
  35 {
  36   epsnl  = 0.001;
  37   epsdis = 0.001;
  38   epsangk1 = 0.001 ;
  39   epsangk2 = 0.001;
  40   epsangn1 = 0.001 ;
  41   perce = 0.01;
  42   maxlen = 10000 ;
  43 }
  44
  45 /*********************************************************************************/
  46 void InitEpsCurv(Standard_Real&  epsnl ,Standard_Real&  epsdis, Standard_Real& epsangk1,
  47                                Standard_Real& epsangk2, Standard_Real& epsangg1,
  48                                Standard_Real& epsangg2,Standard_Real& percent,
  49                                Standard_Real& maxlen)
  50 {
  51   epsnl  = 0.001 ;
  52   epsdis = 0.001 ;
  53   epsangk1= 0.001 ;
  54   epsangk2= 0.001;
  55   epsangg1= 0.001 ;
  56   epsangg2= 0.001 ;
  57   percent= 0.01;
  58   maxlen= 10000;
  59 }
  60 /*********************************************************************************/
  61
  62 static Standard_Integer surfaceCcontinuity (Draw_Interpretor& di, Standard_Integer n, const char** a)
  63 {
  64   Standard_Real U1, U2, V1, V2, u1, u2, v1, v2;
  65   GeomAbs_Shape TypeCont;
  66   Standard_Integer ord;
  67   Standard_Boolean b1, b2, b3, b4;
  68   Standard_Real epsnl,epsC0,epsC1,epsC2,epsG1,maxlen,perce;
  69   if (n<8) return 1;
  70
  71   InitEpsSurf(epsnl,epsC0,epsC1,epsC2,epsG1,perce,maxlen);
  72
  73   Handle(Geom_Surface) surf1 = DrawTrSurf::GetSurface(a[2]);
  74   if (surf1.IsNull()) return 1 ;
  75
  76   Handle(Geom_Surface) surf2 = DrawTrSurf::GetSurface(a[5]);
  77   if (surf2.IsNull()) return 1;
  78
  79   U1 = Draw::Atof(a[3]);
  80   U2 = Draw::Atof(a[6]);
  81   V1 = Draw::Atof(a[4]);
  82   V2 = Draw::Atof(a[7]);
  83
  84   ord = Draw::Atoi(a[1]);
  85
  86   surf1->Bounds(u1, u2, v1, v2);
  87   b1 = ((((U1>=u1)&&(U1<=u2))||((U1<=u1)&&(U1>=u2))));
  88   b3 = ((((V1>=v1)&&(V1<=v2))||((V1<=v1)&&(V1>=v2))));
  89
  90   surf2->Bounds(u1, u2, v1, v2);
  91   b2 = ((((U2>=u1)&&(U2<=u2))||((U2<=u1)&&(U2>=u2))));
  92   b4 = ((((V2>=v1)&&(V2<=v2))||((V2<=v1)&&(V2>=v2))));
  93
  94   if (!((b1 && b2)&&(b3 && b4))) return 1;
  95
  96   switch ( ord )
  97   {
  98   case 0 :
  99     {
 100       TypeCont = GeomAbs_C0;
 101       switch(n)
 102       {
 103       case 10: epsC0 = Draw::Atof(a[9]);
 104         Standard_FALLTHROUGH
 105       case 9 : epsnl = Draw::Atof(a[8]);
 106         Standard_FALLTHROUGH
 107       case 8 : break;
 108       default :
 109         std::cerr << "Error: invalid number of arguments: expected to get 8 - 10 parameters" << std::endl;
 110         return 1;
 111       }
 112     }
 113     break;
 114
 115   case 1 :
 116     {
 117       TypeCont = GeomAbs_C1;
 118       switch(n)
 119       {
 120       case 11 : epsC1 = Draw::Atof(a[10]);
 121         Standard_FALLTHROUGH
 122       case 10 : epsC0 = Draw::Atof(a[9]);
 123         Standard_FALLTHROUGH
 124       case 9  : epsnl = Draw::Atof(a[8]);
 125         Standard_FALLTHROUGH
 126       case 8  : break;
 127       default :
 128         std::cerr << "Error: invalid number of arguments: expected to get 8 - 11 parameters" << std::endl;
 129         return 1;
 130       }
 131     }
 132     break;
 133
 134   case 2 :
 135     {
 136       TypeCont = GeomAbs_C2;
 137       switch(n)
 138       {
 139       case 12 : epsC2 = Draw::Atof(a[11]);
 140         Standard_FALLTHROUGH
 141       case 11 : epsC1 = Draw::Atof(a[10]);
 142         Standard_FALLTHROUGH
 143       case 10 : epsC0 = Draw::Atof(a[9]);
 144         Standard_FALLTHROUGH
 145       case 9  : epsnl = Draw::Atof(a[8]);
 146         Standard_FALLTHROUGH
 147       case 8  : break;
 148       default :
 149         std::cerr << "Error: invalid number of arguments: expected to get 8 - 12 parameters" << std::endl;
 150         return 1;
 151       }
 152     }
 153     break;
 154   default:
 155     std::cerr << "Error: invalid value of parameter 1 (" << a[1] << "): should be 0, 1, or 2" << std::endl;
 156     return 1;
 157   }
 158
 159   LocalAnalysis_SurfaceContinuity RES (surf1, U1, V1, surf2, U2, V2,
 160                                        TypeCont, epsnl, epsC0, epsC1, epsC2, epsG1, perce, maxlen);
 161   //LocalAnalysis::Dump(RES,std::cout);
 162   Standard_SStream aSStream;
 163   LocalAnalysis::Dump(RES,aSStream);
 164   di << aSStream;
 165   return 0;
 166 }
 167
 168 /*********************************************************************************/
 169
 170 static Standard_Integer surfaceGcontinuity (Draw_Interpretor& di, Standard_Integer n, const char** a)
 171 {
 172   Standard_Real U1, U2, V1, V2,u1, u2, v1, v2;
 173   GeomAbs_Shape TypeCont;
 174   Standard_Integer ord;
 175   Standard_Boolean b1, b2, b3, b4;
 176   Standard_Real epsnl,epsC0,epsC1,epsC2,epsG1,maxlen,perce;
 177
 178   if (n<8) return 1;
 179   InitEpsSurf(epsnl,epsC0,epsC1,epsC2,epsG1,perce,maxlen);
 180
 181   Handle(Geom_Surface) surf1 = DrawTrSurf::GetSurface(a[2]);
 182   if (surf1.IsNull()) return 1 ;
 183
 184   Handle(Geom_Surface) surf2 = DrawTrSurf::GetSurface(a[5]);
 185   if (surf2.IsNull()) return 1;
 186
 187   U1 = Draw::Atof(a[3]);
 188   U2 = Draw::Atof(a[6]);
 189   V1 = Draw::Atof(a[4]);
 190   V2 = Draw::Atof(a[7]);
 191
 192   ord = Draw::Atoi(a[1]);
 193
 194   surf1->Bounds(u1, u2, v1, v2);
 195   b1 = ((((U1>=u1)&&(U1<=u2))||((U1<=u1)&&(U1>=u2))));
 196   b3 = ((((V1>=v1)&&(V1<=v2))||((V1<=v1)&&(V1>=v2))));
 197
 198   surf2->Bounds(u1, u2, v1, v2);
 199   b2 = ((((U2>=u1)&&(U2<=u2))||((U2<=u1)&&(U2>=u2))));
 200   b4 = ((((V2>=v1)&&(V2<=v2))||((V2<=v1)&&(V2>=v2))));
 201
 202   if (!((b1 && b2)&&(b3 && b4))) return 1;
 203
 204
 205   switch ( ord )
 206   {
 207   case 1 :
 208     {
 209       TypeCont = GeomAbs_G1;
 210       switch(n)
 211       {
 212       case 11 : epsG1 = Draw::Atof(a[10]);
 213         Standard_FALLTHROUGH
 214       case 10 : epsC0 = Draw::Atof(a[9]);
 215         Standard_FALLTHROUGH
 216       case 9  : epsnl = Draw::Atof(a[8]);
 217         Standard_FALLTHROUGH
 218       case 8  : break;
 219       default :
 220         std::cerr << "Error: invalid number of arguments: expected to get 8 - 11 parameters" << std::endl;
 221         return 1;
 222       }
 223     }
 224     break;
 225
 226   case 2 :
 227     {
 228       TypeCont = GeomAbs_G2;
 229       switch(n)
 230       {
 231       case 13 : maxlen = Draw::Atof (a[12]);
 232         Standard_FALLTHROUGH
 233       case 12 : perce = Draw::Atof(a[11]);
 234         Standard_FALLTHROUGH
 235       case 11 : epsG1 = Draw::Atof(a[10]);
 236         Standard_FALLTHROUGH
 237       case 10 : epsC0 = Draw::Atof(a[9]);
 238         Standard_FALLTHROUGH
 239       case 9  : epsnl = Draw::Atof(a[8]);
 240         Standard_FALLTHROUGH
 241       case 8  : break;
 242       default :
 243         std::cerr << "Error: invalid number of arguments: expected to get 8 - 13 parameters" << std::endl;
 244         return 1;
 245       }
 246     }
 247     break;
 248   default:
 249     std::cerr << "Error: invalid value of parameter 1 (" << a[1] << "): should be 1 or 2" << std::endl;
 250     return 1;
 251   }
 252
 253   LocalAnalysis_SurfaceContinuity RES (surf1, U1, V1, surf2, U2, V2,
 254                                        TypeCont, epsnl, epsC0, epsC1, epsC2, epsG1, perce, maxlen);
 255   //LocalAnalysis::Dump(RES,std::cout);
 256   Standard_SStream aSStream;
 257   LocalAnalysis::Dump(RES,aSStream);
 258   di << aSStream;
 259   return 0;
 260 }
 261
 262 /*********************************************************************************/
 263
 264 static Standard_Integer curveGcontinuity(Draw_Interpretor& di, Standard_Integer n, const char** a)
 265 {
 266   Standard_Real U1, U2, u1, u2;
 267   GeomAbs_Shape  TypeCont;
 268   Standard_Integer ord;
 269   Standard_Boolean b1, b2;
 270   Standard_Real  epsnl,epsC0, epsC1, epsC2, epsG1, epsG2, maxlen,percent;
 271   if (n<6) return 1;
 272
 273   Handle(Geom_Curve) curv1 = DrawTrSurf::GetCurve(a[2]);
 274   if (curv1.IsNull()) return 1;
 275   Handle(Geom_Curve) curv2 = DrawTrSurf::GetCurve(a[4]);
 276   if (curv2.IsNull()) return 1;
 277
 278   U1 = Draw::Atof(a[3]);
 279   U2 = Draw::Atof(a[5]);
 280
 281   ord = Draw::Atoi(a[1]);
 282
 283   u1=curv1->FirstParameter();
 284   u2=curv1->LastParameter();
 285   b1 = ((((U1>=u1)&&(U1<=u2))||((U1<=u1)&&(U1>=u2))));
 286
 287   u1=curv2->FirstParameter();
 288   u2=curv2->LastParameter();
 289   b2 = ((((U2>=u1)&&(U2<=u2))||((U2<=u1)&&(U2>=u2))));
 290
 291   if (!(b1 && b2)) return 1;
 292
 293   InitEpsCurv( epsnl,epsC0, epsC1, epsC2, epsG1, epsG2, percent,maxlen);
 294   switch ( ord )
 295   {
 296   case 1 :
 297     {
 298       TypeCont = GeomAbs_G1;
 299       switch(n)
 300       {
 301       case 9 :  epsG1 = Draw::Atof(a[8]);
 302         Standard_FALLTHROUGH
 303       case 8  : epsC0 = Draw::Atof(a[7]);
 304         Standard_FALLTHROUGH
 305       case 7  : epsnl = Draw::Atof(a[6]);
 306         Standard_FALLTHROUGH
 307       case 6  : break;
 308       default :
 309         std::cerr << "Error: invalid number of arguments: expected to get 6 - 8 parameters" << std::endl;
 310         return 1;
 311       }
 312     }
 313     break;
 314   case 2 :
 315     {
 316       TypeCont = GeomAbs_G2;
 317       switch(n)
 318       {
 319       case 12 : maxlen = Draw::Atof(a[11]);
 320         Standard_FALLTHROUGH
 321       case 11 : percent = Draw::Atof(a[10]);
 322         Standard_FALLTHROUGH
 323       case 10 : epsG2 = Draw::Atof(a[9]);
 324         Standard_FALLTHROUGH
 325       case 9  : epsG1 = Draw::Atof(a[8]);
 326         Standard_FALLTHROUGH
 327       case 8  : epsC0 = Draw::Atof(a[7]);
 328         Standard_FALLTHROUGH
 329       case 7  : epsnl = Draw::Atof(a[6]);
 330         Standard_FALLTHROUGH
 331       case 6  : break;
 332       default :
 333         std::cerr << "Error: invalid number of arguments: expected to get 6 - 12 parameters" << std::endl;
 334         return 1;
 335       }
 336     }
 337     break;
 338
 339   default:
 340     std::cerr << "Error: invalid value of parameter 1 (" << a[1] << "): should be 1 or 2" << std::endl;
 341     return 1;
 342   }
 343
 344   LocalAnalysis_CurveContinuity RES (curv1, U1, curv2, U2, TypeCont,
 345                                      epsnl, epsC0, epsC1, epsC2, epsG1, epsG2, percent, maxlen);
 346   //LocalAnalysis::Dump(RES,std::cout);
 347   Standard_SStream aSStream;
 348   LocalAnalysis::Dump(RES,aSStream);
 349   di << aSStream;
 350   return 0;
 351 }
 352
 353 /*********************************************************************************/
 354
 355 static Standard_Integer curveCcontinuity(Draw_Interpretor& di, Standard_Integer n, const char** a)
 356 {
 357   Standard_Real U1, U2, u1, u2;
 358   GeomAbs_Shape  TypeCont;
 359   Standard_Integer ord;
 360   Standard_Boolean b1, b2;
 361   Standard_Real  epsnl,epsC0, epsC1, epsC2, epsG1, epsG2, maxlen,percent;
 362   if (n<6) return 1;
 363
 364   Handle(Geom_Curve) curv1 = DrawTrSurf::GetCurve(a[2]);
 365   if (curv1.IsNull()) return 1;
 366   Handle(Geom_Curve) curv2 = DrawTrSurf::GetCurve(a[4]);
 367   if (curv2.IsNull()) return 1;
 368
 369   U1 = Draw::Atof(a[3]);
 370   U2 = Draw::Atof(a[5]);
 371
 372   ord = Draw::Atoi(a[1]);
 373
 374   u1=curv1->FirstParameter();
 375   u2=curv1->LastParameter();
 376   b1 = ((((U1>=u1)&&(U1<=u2))||((U1<=u1)&&(U1>=u2))));
 377
 378   u1=curv2->FirstParameter();
 379   u2=curv2->LastParameter();
 380   b2 = ((((U2>=u1)&&(U2<=u2))||((U2<=u1)&&(U2>=u2))));
 381
 382   if (!(b1 && b2)) return 1;
 383
 384   InitEpsCurv( epsnl,epsC0, epsC1, epsC2, epsG1, epsG2, percent,maxlen);
 385   switch ( ord )
 386   {
 387   case 0 :
 388     {
 389       TypeCont = GeomAbs_C0;
 390       switch(n)
 391       {
 392       case 8  : epsC0 = Draw::Atof(a[7]);
 393         Standard_FALLTHROUGH
 394       case 7  : epsnl = Draw::Atof(a[6]);
 395         Standard_FALLTHROUGH
 396       case 6  : break;
 397       default :
 398         std::cerr << "Error: invalid number of arguments: expected to get 6 - 8 parameters" << std::endl;
 399         return 1;
 400       }
 401     }
 402     break;
 403   case 1 :
 404     {
 405       TypeCont = GeomAbs_C1;
 406       switch(n)
 407       {
 408       case 9 : epsC1 = Draw::Atof(a[8]);
 409         Standard_FALLTHROUGH
 410       case 8 : epsC0 = Draw::Atof(a[7]);
 411         Standard_FALLTHROUGH
 412       case 7 : epsnl = Draw::Atof(a[6]);
 413         Standard_FALLTHROUGH
 414       case 6 : break;
 415       default :
 416         std::cerr << "Error: invalid number of arguments: expected to get 6 - 9 parameters" << std::endl;
 417         return 1;
 418       }
 419     }
 420     break;
 421
 422   case 2 :
 423     {
 424       TypeCont = GeomAbs_C2;
 425       switch(n)
 426       {
 427       case 10 : epsC2 = Draw::Atof(a[9]);
 428         Standard_FALLTHROUGH
 429       case 9  : epsC1 = Draw::Atof(a[8]);
 430         Standard_FALLTHROUGH
 431       case 8  : epsC0 = Draw::Atof(a[7]);
 432         Standard_FALLTHROUGH
 433       case 7  : epsnl = Draw::Atof(a[6]);
 434         Standard_FALLTHROUGH
 435       case 6  : break;
 436       default :
 437         std::cerr << "Error: invalid number of arguments: expected to get 6 - 10 parameters" << std::endl;
 438         return 1;
 439       }
 440     }
 441     break;
 442
 443   default:
 444     std::cerr << "Error: invalid value of parameter 1 (" << a[1] << "): should be 0, 1, or 2" << std::endl;
 445     return 1;
 446   }
 447
 448   LocalAnalysis_CurveContinuity RES (curv1, U1, curv2, U2, TypeCont,
 449                                      epsnl, epsC0, epsC1, epsC2, epsG1, epsG2, percent, maxlen);
 450   //LocalAnalysis::Dump(RES,std::cout);
 451   Standard_SStream aSStream;
 452   LocalAnalysis::Dump(RES,aSStream);
 453   di << aSStream;
 454   return 0;
 455 }
 456
 457 /***************************************************************************/
 458 void GeometryTest::ContinuityCommands( Draw_Interpretor& theCommands)
 459 {
 460   static Standard_Boolean loaded = Standard_False;
 461   if ( loaded) return;
 462   loaded = Standard_True;
 463
 464   DrawTrSurf::BasicCommands(theCommands);
 465   const char* g;
 466
 467   g = "GEOMETRY curves and surfaces continuity analysis ";
 468
 469   theCommands.Add("surfaceCcontinuity",
 470                   " surfaceCcontinuity   order surf1 parU1 parV1 surf2 parU2 parV2  [eps_nul[ epsC0 [epsC1 [epsC2]]]]",
 471                   __FILE__,
 472                   surfaceCcontinuity ,g);
 473
 474   theCommands.Add("surfaceGcontinuity",
 475                   " surfaceGcontinuity   order surf1 parU1 parV1 surf2 parU2 parV2  [eps_nul[ epsG0 [epsG1[percent [maxlen]]]]",
 476                   __FILE__,
 477                   surfaceGcontinuity ,g);
 478
 479   theCommands.Add("curveCcontinuity",
 480                   "curveCcontinuity   order curv1 u1  curv2  u2   [epsnul  [epsC0 [epsC1  [epsC2 ]]]]  ",
 481                   __FILE__,
 482                   curveCcontinuity,g);
 483
 484
 485   theCommands.Add("curveGcontinuity",
 486                   "curveGcontinuity   order  curv1 u1  curv2  u2   [epsnul  [epsG0  [epsG1  [epsG2 [percent  [maxlen ]]]]]] ",
 487                    __FILE__,
 488                   curveGcontinuity,g);
 489 }
 490
 491
 492
 493
 494
 495
 496
 497