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 { Standard_Real U1, U2, V1, V2, u1, u2, v1, v2;
  64   GeomAbs_Shape TypeCont;
  65   Standard_Integer ord;
  66   Standard_Boolean b1, b2, b3, b4;
  67   Standard_Real epsnl,epsC0,epsC1,epsC2,epsG1,maxlen,perce;
  68   if (n<8) return 1;
  69
  70   InitEpsSurf(epsnl,epsC0,epsC1,epsC2,epsG1,perce,maxlen);
  71
  72   Handle(Geom_Surface) surf1 = DrawTrSurf::GetSurface(a[2]);
  73   if (surf1.IsNull()) return 1 ;
  74
  75   Handle(Geom_Surface) surf2 = DrawTrSurf::GetSurface(a[5]);
  76   if (surf2.IsNull()) return 1;
  77
  78       U1 = Draw::Atof(a[3]);
  79       U2 = Draw::Atof(a[6]);
  80       V1 = Draw::Atof(a[4]);
  81       V2 = Draw::Atof(a[7]);
  82
  83       ord = Draw::Atoi(a[1]);
  84
  85       surf1->Bounds(u1, u2, v1, v2);
  86       b1 = ((((U1>=u1)&&(U1<=u2))||((U1<=u1)&&(U1>=u2))));
  87       b3 = ((((V1>=v1)&&(V1<=v2))||((V1<=v1)&&(V1>=v2))));
  88
  89       surf2->Bounds(u1, u2, v1, v2);
  90       b2 = ((((U2>=u1)&&(U2<=u2))||((U2<=u1)&&(U2>=u2))));
  91       b4 = ((((V2>=v1)&&(V2<=v2))||((V2<=v1)&&(V2>=v2))));
  92
  93       if (!((b1 && b2)&&(b3 && b4))) return 1;
  94
  95
  96        switch ( ord )
  97        { case 0 : { TypeCont=GeomAbs_C0;
  98                     switch(n)
  99                         { case 10  : epsC0= Draw::Atof(a[9]);
 100                           case 9   : epsnl = Draw::Atof(a[8]);
 101                           case 8 : {} break;
 102                           default : return 1;
 103                         }
 104                     LocalAnalysis_SurfaceContinuity RES (surf1, U1, V1, surf2, U2, V2,
 105                     TypeCont,epsnl,epsC0,epsC1,epsC2,epsG1,perce,maxlen);
 106                     //LocalAnalysis::Dump(RES,cout);
 107                     Standard_SStream aSStream;
 108                     LocalAnalysis::Dump(RES,aSStream);
 109                     di << aSStream;
 110                   }
 111                   break;
 112          case 1 : { TypeCont=GeomAbs_C1;
 113                      switch(n)
 114                         { case 11 : epsC1=Draw::Atof(a[10]);
 115                           case 10  : epsC0= Draw::Atof(a[9]);
 116                           case 9  : epsnl = Draw::Atof(a[8]);
 117                           case 8  : {} break;
 118                           default : return 1;
 119                         }
 120                     LocalAnalysis_SurfaceContinuity RES (surf1, U1, V1, surf2, U2, V2,
 121                     TypeCont,epsnl,epsC0,epsC1,epsC2,epsG1,perce,maxlen );
 122                     //LocalAnalysis::Dump(RES,cout);
 123                     Standard_SStream aSStream;
 124                     LocalAnalysis::Dump(RES,aSStream);
 125                     di << aSStream;
 126
 127                   }
 128                   break;
 129          case 2 : { TypeCont=GeomAbs_C2;
 130                     switch(n)
 131                        {
 132                           case 12 : epsC2= Draw::Atof(a[11]);
 133                           case 11 : epsC1=Draw::Atof(a[10]);
 134                           case 10 : epsC0= Draw::Atof(a[9]);
 135                           case 9  : epsnl = Draw::Atof(a[8]);
 136                           case 8  : {} break;
 137                           default : return 1;
 138                         }
 139                     LocalAnalysis_SurfaceContinuity RES (surf1, U1, V1, surf2, U2, V2,
 140                            TypeCont, epsnl,epsC0,epsC1,epsC2,epsG1,perce,maxlen  );
 141                     //LocalAnalysis::Dump(RES,cout);
 142                     Standard_SStream aSStream;
 143                     LocalAnalysis::Dump(RES,aSStream);
 144                     di << aSStream;
 145                   }
 146                   break;
 147
 148
 149         default : {}
 150        }
 151    return 0;
 152 }
 153
 154 /*********************************************************************************/
 155
 156 static Standard_Integer surfaceGcontinuity (Draw_Interpretor& di, Standard_Integer n, const char** a)
 157 { Standard_Real U1, U2, V1, V2,u1, u2, v1, v2;
 158   GeomAbs_Shape TypeCont;
 159   Standard_Integer ord;
 160   Standard_Boolean b1, b2, b3, b4;
 161   Standard_Real epsnl,epsC0,epsC1,epsC2,epsG1,maxlen,perce;
 162
 163   if (n<8) return 1;
 164   InitEpsSurf(epsnl,epsC0,epsC1,epsC2,epsG1,perce,maxlen);
 165
 166   Handle(Geom_Surface) surf1 = DrawTrSurf::GetSurface(a[2]);
 167   if (surf1.IsNull()) return 1 ;
 168
 169   Handle(Geom_Surface) surf2 = DrawTrSurf::GetSurface(a[5]);
 170   if (surf2.IsNull()) return 1;
 171
 172       U1 = Draw::Atof(a[3]);
 173       U2 = Draw::Atof(a[6]);
 174       V1 = Draw::Atof(a[4]);
 175       V2 = Draw::Atof(a[7]);
 176
 177       ord = Draw::Atoi(a[1]);
 178
 179       surf1->Bounds(u1, u2, v1, v2);
 180       b1 = ((((U1>=u1)&&(U1<=u2))||((U1<=u1)&&(U1>=u2))));
 181       b3 = ((((V1>=v1)&&(V1<=v2))||((V1<=v1)&&(V1>=v2))));
 182
 183       surf2->Bounds(u1, u2, v1, v2);
 184       b2 = ((((U2>=u1)&&(U2<=u2))||((U2<=u1)&&(U2>=u2))));
 185       b4 = ((((V2>=v1)&&(V2<=v2))||((V2<=v1)&&(V2>=v2))));
 186
 187       if (!((b1 && b2)&&(b3 && b4))) return 1;
 188
 189
 190        switch ( ord )
 191        {
 192          case 1 : { TypeCont=GeomAbs_G1;
 193                      switch(n)
 194                          { case 11 : epsG1=Draw::Atof(a[10]);
 195                           case 10  : epsC0= Draw::Atof(a[9]);
 196                           case 9  : epsnl = Draw::Atof(a[8]);
 197                           case 8  : {} break;
 198                           default : return 1;
 199                         }
 200                    LocalAnalysis_SurfaceContinuity RES (surf1, U1, V1, surf2, U2, V2,
 201                       TypeCont,epsnl,epsC0,epsC1,epsC2,epsG1,perce,maxlen );
 202                     //LocalAnalysis::Dump(RES,cout);
 203                     Standard_SStream aSStream;
 204                     LocalAnalysis::Dump(RES,aSStream);
 205                     di << aSStream;
 206
 207                   }
 208                   break;
 209          case 2 : { TypeCont=GeomAbs_G2;
 210                     switch(n)
 211                       {   case 13 : maxlen =Draw::Atof (a[12]);
 212                           case 12 :  perce=Draw::Atof(a[11]);
 213                           case 11 : epsG1=Draw::Atof(a[10]);
 214                           case 10 : epsC0= Draw::Atof(a[9]);
 215                           case 9  : epsnl = Draw::Atof(a[8]);
 216                           case 8  : {} break;
 217                           default : return 1;
 218                         }
 219                    LocalAnalysis_SurfaceContinuity RES (surf1, U1, V1, surf2, U2, V2,
 220                           TypeCont, epsnl,epsC0,epsC1,epsC2,epsG1,perce,maxlen  );
 221                     //LocalAnalysis::Dump(RES,cout);
 222                     Standard_SStream aSStream;
 223                     LocalAnalysis::Dump(RES,aSStream);
 224                     di << aSStream;
 225                   }
 226                   break;
 227
 228
 229         default : {}
 230        }
 231    return 0;
 232 }
 233
 234 /*********************************************************************************/
 235
 236 static Standard_Integer curveGcontinuity(Draw_Interpretor& di, Standard_Integer n, const char** a)
 237 { Standard_Real U1, U2, u1, u2;
 238   GeomAbs_Shape  TypeCont;
 239   Standard_Integer ord;
 240   Standard_Boolean b1, b2;
 241   Standard_Real  epsnl,epsC0, epsC1, epsC2, epsG1, epsG2, maxlen,percent;
 242   if (n<6) return 1;
 243
 244   Handle(Geom_Curve) curv1 = DrawTrSurf::GetCurve(a[2]);
 245   if (curv1.IsNull()) return 1;
 246   Handle(Geom_Curve) curv2 = DrawTrSurf::GetCurve(a[4]);
 247   if (curv2.IsNull()) return 1;
 248
 249   U1 = Draw::Atof(a[3]);
 250   U2 = Draw::Atof(a[5]);
 251
 252   ord = Draw::Atoi(a[1]);
 253
 254   u1=curv1->FirstParameter();
 255   u2=curv1->LastParameter();
 256   b1 = ((((U1>=u1)&&(U1<=u2))||((U1<=u1)&&(U1>=u2))));
 257
 258   u1=curv2->FirstParameter();
 259   u2=curv2->LastParameter();
 260   b2 = ((((U2>=u1)&&(U2<=u2))||((U2<=u1)&&(U2>=u2))));
 261
 262   if (!(b1 && b2)) return 1;
 263
 264   InitEpsCurv( epsnl,epsC0, epsC1, epsC2, epsG1, epsG2, percent,maxlen);
 265   switch ( ord )
 266        {
 267           case 1 : {
 268                     switch(n)
 269                         { case 9 :  epsG1=Draw::Atof(a[8]);
 270                           case 8  : epsC0= Draw::Atof(a[7]);
 271                           case 7  : epsnl = Draw::Atof(a[6]);
 272                           case 6  : {} break;
 273                           default : return 1;
 274                         }
 275                     TypeCont=GeomAbs_G1;
 276                     LocalAnalysis_CurveContinuity RES (curv1, U1, curv2, U2, TypeCont,
 277                     epsnl,epsC0, epsC1, epsC2, epsG1,epsG2,percent,maxlen  );
 278                     //LocalAnalysis::Dump(RES,cout);
 279                     Standard_SStream aSStream;
 280                     LocalAnalysis::Dump(RES,aSStream);
 281                     di << aSStream;
 282                   }
 283                   break;
 284          case 2 : {
 285                     TypeCont=GeomAbs_G2;
 286                     switch(n)
 287                        {case 12 :maxlen =Draw::Atof(a[11]);
 288                         case  11 :percent=Draw::Atof(a[10]);
 289                         case 10 : epsG2= Draw::Atof(a[9]);
 290                         case 9 : epsG1=Draw::Atof(a[8]);
 291                         case 8  : epsC0= Draw::Atof(a[7]);
 292                         case 7  : epsnl = Draw::Atof(a[6]);
 293                         case 6  : {} break;
 294                         default : return 1;
 295                         }
 296                      LocalAnalysis_CurveContinuity RES (curv1, U1, curv2, U2, TypeCont,
 297                          epsnl,epsC0, epsC1, epsC2, epsG1, epsG2,percent,maxlen  );
 298                      //LocalAnalysis::Dump(RES,cout);
 299                     Standard_SStream aSStream;
 300                     LocalAnalysis::Dump(RES,aSStream);
 301                     di << aSStream;
 302                   }
 303                   break;
 304         default : {}
 305        }
 306     return 0;
 307     }
 308
 309 /*********************************************************************************/
 310
 311 static Standard_Integer curveCcontinuity(Draw_Interpretor& di, Standard_Integer n, const char** a)
 312 { Standard_Real U1, U2, u1, u2;
 313   GeomAbs_Shape  TypeCont;
 314   Standard_Integer ord;
 315   Standard_Boolean b1, b2;
 316   Standard_Real  epsnl,epsC0, epsC1, epsC2, epsG1, epsG2, maxlen,percent;
 317   if (n<6) return 1;
 318
 319   Handle(Geom_Curve) curv1 = DrawTrSurf::GetCurve(a[2]);
 320   if (curv1.IsNull()) return 1;
 321   Handle(Geom_Curve) curv2 = DrawTrSurf::GetCurve(a[4]);
 322   if (curv2.IsNull()) return 1;
 323
 324    U1 = Draw::Atof(a[3]);
 325    U2 = Draw::Atof(a[5]);
 326
 327    ord = Draw::Atoi(a[1]);
 328
 329    u1=curv1->FirstParameter();
 330    u2=curv1->LastParameter();
 331    b1 = ((((U1>=u1)&&(U1<=u2))||((U1<=u1)&&(U1>=u2))));
 332
 333    u1=curv2->FirstParameter();
 334    u2=curv2->LastParameter();
 335    b2 = ((((U2>=u1)&&(U2<=u2))||((U2<=u1)&&(U2>=u2))));
 336
 337    if (!(b1 && b2)) return 1;
 338
 339
 340    InitEpsCurv( epsnl,epsC0, epsC1, epsC2, epsG1, epsG2, percent,maxlen);
 341    switch ( ord )
 342        { case 0 : {  switch(n)
 343                         { case 8  : epsC0= Draw::Atof(a[7]);
 344                           case 7  : epsnl = Draw::Atof(a[6]);
 345                           case 6  : {} break;
 346                           default : return 1;
 347                         }
 348                       TypeCont=GeomAbs_C0;
 349                       LocalAnalysis_CurveContinuity  RES (curv1, U1, curv2, U2, TypeCont,
 350                        epsnl,epsC0, epsC1, epsC2, epsG1,epsG2,percent,maxlen  );
 351                      //LocalAnalysis::Dump(RES,cout);
 352                      Standard_SStream aSStream;
 353                      LocalAnalysis::Dump(RES,aSStream);
 354                      di << aSStream;
 355
 356                    }  break;
 357          case 1 : { switch(n)
 358                         { case 9 : epsC1 =Draw::Atof(a[8]);
 359                           case 8  : epsC0= Draw::Atof(a[7]);
 360                           case 7  : epsnl = Draw::Atof(a[6]);
 361                           case 6  : {} break;
 362                           default : return 1;
 363                         }
 364                     TypeCont=GeomAbs_C1;
 365                     LocalAnalysis_CurveContinuity RES (curv1, U1, curv2, U2, TypeCont,
 366                     epsnl,epsC0, epsC1, epsC2, epsG1,epsG2,percent,maxlen  );
 367                     //LocalAnalysis::Dump(RES,cout);
 368                     Standard_SStream aSStream;
 369                     LocalAnalysis::Dump(RES,aSStream);
 370                     di << aSStream;
 371
 372                   } break;
 373          case 2 : {  TypeCont=GeomAbs_C2;
 374                      switch(n)
 375                        {
 376                           case 10 : epsC2= Draw::Atof(a[9]);
 377                           case 9  : epsC1=Draw::Atof(a[8]);
 378                           case 8  : epsC0= Draw::Atof(a[7]);
 379                           case 7  : epsnl = Draw::Atof(a[6]);
 380                           case 6  : {} break;
 381                           default : return 1;
 382                         }
 383                     LocalAnalysis_CurveContinuity RES (curv1, U1, curv2, U2, TypeCont,
 384                     epsnl,epsC0, epsC1, epsC2, epsG1, epsG2,percent,maxlen  );
 385                     //LocalAnalysis::Dump(RES,cout);
 386                     Standard_SStream aSStream;
 387                     LocalAnalysis::Dump(RES,aSStream);
 388                     di << aSStream;
 389                   }
 390                   break;
 391         default : {}
 392        }
 393     return 0;
 394     }
 395 /***************************************************************************/
 396 void GeometryTest::ContinuityCommands( Draw_Interpretor& theCommands)
 397 {
 398   static Standard_Boolean loaded = Standard_False;
 399   if ( loaded) return;
 400   loaded = Standard_True;
 401
 402   DrawTrSurf::BasicCommands(theCommands);
 403   const char* g;
 404
 405   g = "GEOMETRY curves and surfaces continuity analysis ";
 406
 407
 408
 409   theCommands.Add("surfaceCcontinuity",
 410                   " surfaceCcontinuity   order surf1 parU1 parV1 surf2 parU2 parV2  [eps_nul[ epsC0 [epsC1 [epsC2]]]]",
 411                   __FILE__,
 412                   surfaceCcontinuity ,g);
 413
 414   theCommands.Add("surfaceGcontinuity",
 415                   " surfaceGcontinuity   order surf1 parU1 parV1 surf2 parU2 parV2  [eps_nul[ epsG0 [epsG1[percent [maxlen]]]]",
 416                   __FILE__,
 417                   surfaceGcontinuity ,g);
 418
 419   theCommands.Add("curveCcontinuity",
 420                   "curveCcontinuity   order curv1 u1  curv2  u2   [epsnul  [epsC0 [epsC1  [epsC2 ]]]]  ",
 421                   __FILE__,
 422                   curveCcontinuity,g);
 423
 424
 425   theCommands.Add("curveGcontinuity",
 426                   "curveGcontinuity   order  curv1 u1  curv2  u2   [epsnul  [epsG0  [epsG1  [epsG2 [percent  [maxlen ]]]]]] ",
 427                    __FILE__,
 428                   curveGcontinuity,g);
 429 }
 430
 431
 432
 433
 434
 435
 436
 437