src/GEOMImpl/GEOMImpl_IMeasureOperations.cxx

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #include <GEOMImpl_IMeasureOperations.hxx>
  24 #include <GEOMImpl_IMeasure.hxx>
  25 #include <GEOMImpl_MeasureDriver.hxx>
  26 #include <GEOMImpl_Types.hxx>
  27
  28 #include <GEOMUtils.hxx>
  29
  30 #include <GEOMAlgo_AlgoTools.hxx>
  31 #include <GEOMAlgo_KindOfName.hxx>
  32 #include <GEOMAlgo_ShapeInfoFiller.hxx>
  33
  34 #include <GEOM_PythonDump.hxx>
  35
  36 #include <utilities.h>
  37
  38 // OCCT Includes
  39 #include <Bnd_Box.hxx>
  40 #include <BOPAlgo_CheckerSI.hxx>
  41 #include <BOPCol_ListOfShape.hxx>
  42 #include <BOPDS_DS.hxx>
  43 #include <BOPDS_MapOfPassKey.hxx>
  44 #include <BRepBndLib.hxx>
  45 #include <BRepBuilderAPI_Copy.hxx>
  46 #include <BRepCheck_ListIteratorOfListOfStatus.hxx>
  47 #include <BRepCheck_Shell.hxx>
  48 #include <BRepClass3d_SolidClassifier.hxx>
  49 #include <BRepClass_FaceClassifier.hxx>
  50 #include <BRepExtrema_DistShapeShape.hxx>
  51 #include <BRepGProp.hxx>
  52 #include <BRepTools.hxx>
  53 #include <BRep_Tool.hxx>
  54 #include <Geom_Line.hxx>
  55 #include <GeomAPI_ProjectPointOnCurve.hxx>
  56 #include <GeomAPI_ProjectPointOnSurf.hxx>
  57 #include <GeomLProp_CLProps.hxx>
  58 #include <GeomLProp_SLProps.hxx>
  59 #include <GProp_GProps.hxx>
  60 #include <GProp_PrincipalProps.hxx>
  61 #include <ShapeAnalysis.hxx>
  62 #include <ShapeAnalysis_Surface.hxx>
  63 #include <TopExp.hxx>
  64 #include <TopExp_Explorer.hxx>
  65 #include <TopoDS.hxx>
  66 #include <TopoDS_Edge.hxx>
  67 #include <TopTools_IndexedMapOfShape.hxx>
  68 #include <TopTools_DataMapIteratorOfDataMapOfIntegerListOfShape.hxx>
  69 #include <TopTools_ListIteratorOfListOfShape.hxx>
  70 #include <TopTools_ListOfShape.hxx>
  71 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
  72
  73 //=============================================================================
  74 /*!
  75  *  Constructor
  76  */
  77 //=============================================================================
  78 GEOMImpl_IMeasureOperations::GEOMImpl_IMeasureOperations (GEOM_Engine* theEngine, int theDocID)
  79 : GEOM_IOperations(theEngine, theDocID)
  80 {
  81   MESSAGE("GEOMImpl_IMeasureOperations::GEOMImpl_IMeasureOperations");
  82 }
  83
  84 //=============================================================================
  85 /*!
  86  *  Destructor
  87  */
  88 //=============================================================================
  89 GEOMImpl_IMeasureOperations::~GEOMImpl_IMeasureOperations()
  90 {
  91   MESSAGE("GEOMImpl_IMeasureOperations::~GEOMImpl_IMeasureOperations");
  92 }
  93
  94 //=============================================================================
  95 /*! Get kind and parameters of the given shape.
  96  */
  97 //=============================================================================
  98 GEOMImpl_IMeasureOperations::ShapeKind GEOMImpl_IMeasureOperations::KindOfShape
  99                              (Handle(GEOM_Object) theShape,
 100                               Handle(TColStd_HSequenceOfInteger)& theIntegers,
 101                               Handle(TColStd_HSequenceOfReal)&    theDoubles)
 102 {
 103   SetErrorCode(KO);
 104   ShapeKind aKind = SK_NO_SHAPE;
 105
 106   if (theIntegers.IsNull()) theIntegers = new TColStd_HSequenceOfInteger;
 107   else                      theIntegers->Clear();
 108
 109   if (theDoubles.IsNull()) theDoubles = new TColStd_HSequenceOfReal;
 110   else                     theDoubles->Clear();
 111
 112   if (theShape.IsNull())
 113     return aKind;
 114
 115   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
 116   if (aRefShape.IsNull()) return aKind;
 117
 118   TopoDS_Shape aShape = aRefShape->GetValue();
 119   if (aShape.IsNull()) return aKind;
 120
 121   int geom_type = theShape->GetType();
 122
 123   // check if it's advanced shape
 124   if ( geom_type > ADVANCED_BASE ) {
 125     SetErrorCode(OK);
 126     return SK_ADVANCED;
 127   }
 128
 129   // Call algorithm
 130   GEOMAlgo_ShapeInfoFiller aSF;
 131   aSF.SetShape(aShape);
 132   aSF.Perform();
 133   Standard_Integer iErr = aSF.ErrorStatus();
 134   if (iErr) {
 135     SetErrorCode("Error in GEOMAlgo_ShapeInfoFiller");
 136     return SK_NO_SHAPE;
 137   }
 138   const GEOMAlgo_ShapeInfo& anInfo = aSF.Info();
 139
 140   // Interprete results
 141   TopAbs_ShapeEnum aType = anInfo.Type();
 142   switch (aType)
 143   {
 144   case TopAbs_COMPOUND:
 145   case TopAbs_COMPSOLID:
 146     {
 147       // (+) geompy.kind.COMPOUND     nb_solids nb_faces nb_edges nb_vertices
 148       // (+) geompy.kind.COMPSOLID    nb_solids nb_faces nb_edges nb_vertices
 149       // ??? "nb_faces" - all faces or only 'standalone' faces?
 150       if (aType == TopAbs_COMPOUND)
 151         aKind = SK_COMPOUND;
 152       else
 153         aKind = SK_COMPSOLID;
 154
 155       //theIntegers->Append(anInfo.NbSubShapes(TopAbs_COMPOUND));
 156       //theIntegers->Append(anInfo.NbSubShapes(TopAbs_COMPSOLID));
 157       theIntegers->Append(anInfo.NbSubShapes(TopAbs_SOLID));
 158       theIntegers->Append(anInfo.NbSubShapes(TopAbs_FACE));
 159       theIntegers->Append(anInfo.NbSubShapes(TopAbs_EDGE));
 160       theIntegers->Append(anInfo.NbSubShapes(TopAbs_VERTEX));
 161     }
 162     break;
 163
 164   case TopAbs_SHELL:
 165     {
 166       // (+) geompy.kind.SHELL  geompy.info.closed   nb_faces nb_edges nb_vertices
 167       // (+) geompy.kind.SHELL  geompy.info.unclosed nb_faces nb_edges nb_vertices
 168       aKind = SK_SHELL;
 169
 170       theIntegers->Append((int)anInfo.KindOfClosed());
 171
 172       theIntegers->Append(anInfo.NbSubShapes(TopAbs_FACE));
 173       theIntegers->Append(anInfo.NbSubShapes(TopAbs_EDGE));
 174       theIntegers->Append(anInfo.NbSubShapes(TopAbs_VERTEX));
 175     }
 176     break;
 177
 178   case TopAbs_WIRE:
 179     {
 180       // (+) geompy.kind.WIRE  geompy.info.closed   nb_edges nb_vertices
 181       // (+) geompy.kind.WIRE  geompy.info.unclosed nb_edges nb_vertices
 182       aKind = SK_WIRE;
 183
 184       theIntegers->Append((int)anInfo.KindOfClosed());
 185
 186       theIntegers->Append(anInfo.NbSubShapes(TopAbs_EDGE));
 187       theIntegers->Append(anInfo.NbSubShapes(TopAbs_VERTEX));
 188     }
 189     break;
 190
 191   case TopAbs_SOLID:
 192     {
 193       aKind = SK_SOLID;
 194
 195       GEOMAlgo_KindOfName aKN = anInfo.KindOfName();
 196       switch (aKN)
 197       {
 198       case GEOMAlgo_KN_SPHERE:
 199         // (+) geompy.kind.SPHERE  xc yc zc  R
 200         {
 201           aKind = SK_SPHERE;
 202
 203           gp_Pnt aC = anInfo.Location();
 204           theDoubles->Append(aC.X());
 205           theDoubles->Append(aC.Y());
 206           theDoubles->Append(aC.Z());
 207
 208           theDoubles->Append(anInfo.Radius1());
 209         }
 210         break;
 211       case GEOMAlgo_KN_CYLINDER:
 212         // (+) geompy.kind.CYLINDER  xb yb zb  dx dy dz  R  H
 213         {
 214           aKind = SK_CYLINDER;
 215
 216           gp_Pnt aC = anInfo.Location();
 217           theDoubles->Append(aC.X());
 218           theDoubles->Append(aC.Y());
 219           theDoubles->Append(aC.Z());
 220
 221           gp_Ax3 anAx3 = anInfo.Position();
 222           gp_Dir aD = anAx3.Direction();
 223           theDoubles->Append(aD.X());
 224           theDoubles->Append(aD.Y());
 225           theDoubles->Append(aD.Z());
 226
 227           theDoubles->Append(anInfo.Radius1());
 228           theDoubles->Append(anInfo.Height());
 229         }
 230         break;
 231       case GEOMAlgo_KN_BOX:
 232         // (+) geompy.kind.BOX  xc yc zc  ax ay az
 233         {
 234           aKind = SK_BOX;
 235
 236           gp_Pnt aC = anInfo.Location();
 237           theDoubles->Append(aC.X());
 238           theDoubles->Append(aC.Y());
 239           theDoubles->Append(aC.Z());
 240
 241           gp_Ax3 anAx3 = anInfo.Position();
 242           gp_Dir aD = anAx3.Direction();
 243           gp_Dir aX = anAx3.XDirection();
 244
 245           // ax ay az
 246           if (aD.IsParallel(gp::DZ(), Precision::Angular()) &&
 247               aX.IsParallel(gp::DX(), Precision::Angular())) {
 248             theDoubles->Append(anInfo.Length()); // ax'
 249             theDoubles->Append(anInfo.Width());  // ay'
 250             theDoubles->Append(anInfo.Height()); // az'
 251           }
 252           else if (aD.IsParallel(gp::DZ(), Precision::Angular()) &&
 253                    aX.IsParallel(gp::DY(), Precision::Angular())) {
 254             theDoubles->Append(anInfo.Width());  // ay'
 255             theDoubles->Append(anInfo.Length()); // ax'
 256             theDoubles->Append(anInfo.Height()); // az'
 257           }
 258           else if (aD.IsParallel(gp::DX(), Precision::Angular()) &&
 259                    aX.IsParallel(gp::DZ(), Precision::Angular())) {
 260             theDoubles->Append(anInfo.Height()); // az'
 261             theDoubles->Append(anInfo.Width());  // ay'
 262             theDoubles->Append(anInfo.Length()); // ax'
 263           }
 264           else if (aD.IsParallel(gp::DX(), Precision::Angular()) &&
 265                    aX.IsParallel(gp::DY(), Precision::Angular())) {
 266             theDoubles->Append(anInfo.Height()); // az'
 267             theDoubles->Append(anInfo.Length()); // ax'
 268             theDoubles->Append(anInfo.Width());  // ay'
 269           }
 270           else if (aD.IsParallel(gp::DY(), Precision::Angular()) &&
 271                    aX.IsParallel(gp::DZ(), Precision::Angular())) {
 272             theDoubles->Append(anInfo.Width());  // ay'
 273             theDoubles->Append(anInfo.Height()); // az'
 274             theDoubles->Append(anInfo.Length()); // ax'
 275           }
 276           else if (aD.IsParallel(gp::DY(), Precision::Angular()) &&
 277                    aX.IsParallel(gp::DX(), Precision::Angular())) {
 278             theDoubles->Append(anInfo.Length()); // ax'
 279             theDoubles->Append(anInfo.Height()); // az'
 280             theDoubles->Append(anInfo.Width());  // ay'
 281           }
 282           else {
 283             // (+) geompy.kind.ROTATED_BOX  xo yo zo  zx zy zz  xx xy xz  ax ay az
 284             aKind = SK_ROTATED_BOX;
 285
 286             // Direction and XDirection
 287             theDoubles->Append(aD.X());
 288             theDoubles->Append(aD.Y());
 289             theDoubles->Append(aD.Z());
 290
 291             theDoubles->Append(aX.X());
 292             theDoubles->Append(aX.Y());
 293             theDoubles->Append(aX.Z());
 294
 295             // ax ay az
 296             theDoubles->Append(anInfo.Length());
 297             theDoubles->Append(anInfo.Width());
 298             theDoubles->Append(anInfo.Height());
 299           }
 300         }
 301         break;
 302       case GEOMAlgo_KN_TORUS:
 303         // (+) geompy.kind.TORUS  xc yc zc  dx dy dz  R_1 R_2
 304         {
 305           aKind = SK_TORUS;
 306
 307           gp_Pnt aO = anInfo.Location();
 308           theDoubles->Append(aO.X());
 309           theDoubles->Append(aO.Y());
 310           theDoubles->Append(aO.Z());
 311
 312           gp_Ax3 anAx3 = anInfo.Position();
 313           gp_Dir aD = anAx3.Direction();
 314           theDoubles->Append(aD.X());
 315           theDoubles->Append(aD.Y());
 316           theDoubles->Append(aD.Z());
 317
 318           theDoubles->Append(anInfo.Radius1());
 319           theDoubles->Append(anInfo.Radius2());
 320         }
 321         break;
 322       case GEOMAlgo_KN_CONE:
 323         // (+) geompy.kind.CONE  xb yb zb  dx dy dz  R_1 R_2  H
 324         {
 325           aKind = SK_CONE;
 326
 327           gp_Pnt aO = anInfo.Location();
 328           theDoubles->Append(aO.X());
 329           theDoubles->Append(aO.Y());
 330           theDoubles->Append(aO.Z());
 331
 332           gp_Ax3 anAx3 = anInfo.Position();
 333           gp_Dir aD = anAx3.Direction();
 334           theDoubles->Append(aD.X());
 335           theDoubles->Append(aD.Y());
 336           theDoubles->Append(aD.Z());
 337
 338           theDoubles->Append(anInfo.Radius1());
 339           theDoubles->Append(anInfo.Radius2());
 340           theDoubles->Append(anInfo.Height());
 341         }
 342         break;
 343       case GEOMAlgo_KN_POLYHEDRON:
 344         // (+) geompy.kind.POLYHEDRON  nb_faces nb_edges nb_vertices
 345         {
 346           aKind = SK_POLYHEDRON;
 347
 348           theIntegers->Append(anInfo.NbSubShapes(TopAbs_FACE));
 349           theIntegers->Append(anInfo.NbSubShapes(TopAbs_EDGE));
 350           theIntegers->Append(anInfo.NbSubShapes(TopAbs_VERTEX));
 351         }
 352         break;
 353       default:
 354         // (+) geompy.kind.SOLID  nb_faces nb_edges nb_vertices
 355         {
 356           theIntegers->Append(anInfo.NbSubShapes(TopAbs_FACE));
 357           theIntegers->Append(anInfo.NbSubShapes(TopAbs_EDGE));
 358           theIntegers->Append(anInfo.NbSubShapes(TopAbs_VERTEX));
 359         }
 360       }
 361     }
 362     break;
 363
 364   case TopAbs_FACE:
 365     {
 366       aKind = SK_FACE;
 367
 368       GEOMAlgo_KindOfName aKN = anInfo.KindOfName();
 369       switch (aKN) {
 370       case GEOMAlgo_KN_SPHERE:
 371         // (+) geompy.kind.SPHERE2D  xc yc zc  R
 372         {
 373           aKind = SK_SPHERE2D;
 374
 375           gp_Pnt aC = anInfo.Location();
 376           theDoubles->Append(aC.X());
 377           theDoubles->Append(aC.Y());
 378           theDoubles->Append(aC.Z());
 379
 380           theDoubles->Append(anInfo.Radius1());
 381         }
 382         break;
 383       case GEOMAlgo_KN_CYLINDER:
 384         // (+) geompy.kind.CYLINDER2D  xb yb zb  dx dy dz  R  H
 385         {
 386           aKind = SK_CYLINDER2D;
 387
 388           gp_Pnt aO = anInfo.Location();
 389           theDoubles->Append(aO.X());
 390           theDoubles->Append(aO.Y());
 391           theDoubles->Append(aO.Z());
 392
 393           gp_Ax3 anAx3 = anInfo.Position();
 394           gp_Dir aD = anAx3.Direction();
 395           theDoubles->Append(aD.X());
 396           theDoubles->Append(aD.Y());
 397           theDoubles->Append(aD.Z());
 398
 399           theDoubles->Append(anInfo.Radius1());
 400           theDoubles->Append(anInfo.Height());
 401         }
 402         break;
 403       case GEOMAlgo_KN_TORUS:
 404         // (+) geompy.kind.TORUS2D  xc yc zc  dx dy dz  R_1 R_2
 405         {
 406           aKind = SK_TORUS2D;
 407
 408           gp_Pnt aO = anInfo.Location();
 409           theDoubles->Append(aO.X());
 410           theDoubles->Append(aO.Y());
 411           theDoubles->Append(aO.Z());
 412
 413           gp_Ax3 anAx3 = anInfo.Position();
 414           gp_Dir aD = anAx3.Direction();
 415           theDoubles->Append(aD.X());
 416           theDoubles->Append(aD.Y());
 417           theDoubles->Append(aD.Z());
 418
 419           theDoubles->Append(anInfo.Radius1());
 420           theDoubles->Append(anInfo.Radius2());
 421         }
 422         break;
 423       case GEOMAlgo_KN_CONE:
 424         // (+) geompy.kind.CONE2D  xc yc zc  dx dy dz  R_1 R_2  H
 425         {
 426           aKind = SK_CONE2D;
 427
 428           gp_Pnt aO = anInfo.Location();
 429           theDoubles->Append(aO.X());
 430           theDoubles->Append(aO.Y());
 431           theDoubles->Append(aO.Z());
 432
 433           gp_Ax3 anAx3 = anInfo.Position();
 434           gp_Dir aD = anAx3.Direction();
 435           theDoubles->Append(aD.X());
 436           theDoubles->Append(aD.Y());
 437           theDoubles->Append(aD.Z());
 438
 439           theDoubles->Append(anInfo.Radius1());
 440           theDoubles->Append(anInfo.Radius2());
 441           theDoubles->Append(anInfo.Height());
 442         }
 443         break;
 444       case GEOMAlgo_KN_DISKCIRCLE:
 445         // (+) geompy.kind.DISK_CIRCLE  xc yc zc  dx dy dz  R
 446         {
 447           aKind = SK_DISK_CIRCLE;
 448
 449           gp_Pnt aC = anInfo.Location();
 450           theDoubles->Append(aC.X());
 451           theDoubles->Append(aC.Y());
 452           theDoubles->Append(aC.Z());
 453
 454           gp_Ax3 anAx3 = anInfo.Position();
 455           gp_Dir aD = anAx3.Direction();
 456           theDoubles->Append(aD.X());
 457           theDoubles->Append(aD.Y());
 458           theDoubles->Append(aD.Z());
 459
 460           theDoubles->Append(anInfo.Radius1());
 461         }
 462         break;
 463       case GEOMAlgo_KN_DISKELLIPSE:
 464         // (+) geompy.kind.DISK_ELLIPSE  xc yc zc  dx dy dz  R_1 R_2
 465         {
 466           aKind = SK_DISK_ELLIPSE;
 467
 468           gp_Pnt aC = anInfo.Location();
 469           theDoubles->Append(aC.X());
 470           theDoubles->Append(aC.Y());
 471           theDoubles->Append(aC.Z());
 472
 473           gp_Ax3 anAx3 = anInfo.Position();
 474           gp_Dir aD = anAx3.Direction();
 475           theDoubles->Append(aD.X());
 476           theDoubles->Append(aD.Y());
 477           theDoubles->Append(aD.Z());
 478
 479           theDoubles->Append(anInfo.Radius1());
 480           theDoubles->Append(anInfo.Radius2());
 481         }
 482         break;
 483       case GEOMAlgo_KN_RECTANGLE:
 484       case GEOMAlgo_KN_TRIANGLE:
 485       case GEOMAlgo_KN_QUADRANGLE:
 486       case GEOMAlgo_KN_POLYGON:
 487         // (+) geompy.kind.POLYGON  xo yo zo  dx dy dz  nb_edges nb_vertices
 488         {
 489           aKind = SK_POLYGON;
 490
 491           gp_Pnt aO = anInfo.Location();
 492           theDoubles->Append(aO.X());
 493           theDoubles->Append(aO.Y());
 494           theDoubles->Append(aO.Z());
 495
 496           gp_Ax3 anAx3 = anInfo.Position();
 497           gp_Dir aD = anAx3.Direction();
 498           theDoubles->Append(aD.X());
 499           theDoubles->Append(aD.Y());
 500           theDoubles->Append(aD.Z());
 501
 502           theIntegers->Append(anInfo.NbSubShapes(TopAbs_EDGE));
 503           theIntegers->Append(anInfo.NbSubShapes(TopAbs_VERTEX));
 504         }
 505         break;
 506       case GEOMAlgo_KN_PLANE: // infinite
 507         // (+) geompy.kind.PLANE  xo yo zo  dx dy dz
 508         {
 509           aKind = SK_PLANE;
 510
 511           gp_Pnt aC = anInfo.Location();
 512           theDoubles->Append(aC.X());
 513           theDoubles->Append(aC.Y());
 514           theDoubles->Append(aC.Z());
 515
 516           gp_Ax3 anAx3 = anInfo.Position();
 517           gp_Dir aD = anAx3.Direction();
 518           theDoubles->Append(aD.X());
 519           theDoubles->Append(aD.Y());
 520           theDoubles->Append(aD.Z());
 521         }
 522         break;
 523       default:
 524         if (anInfo.KindOfShape() == GEOMAlgo_KS_PLANE) {
 525           // (+) geompy.kind.PLANAR  xo yo zo  dx dy dz  nb_edges nb_vertices
 526
 527           aKind = SK_PLANAR;
 528
 529           gp_Pnt aC = anInfo.Location();
 530           theDoubles->Append(aC.X());
 531           theDoubles->Append(aC.Y());
 532           theDoubles->Append(aC.Z());
 533
 534           gp_Ax3 anAx3 = anInfo.Position();
 535           gp_Dir aD = anAx3.Direction();
 536           theDoubles->Append(aD.X());
 537           theDoubles->Append(aD.Y());
 538           theDoubles->Append(aD.Z());
 539
 540           theIntegers->Append(anInfo.NbSubShapes(TopAbs_EDGE));
 541           theIntegers->Append(anInfo.NbSubShapes(TopAbs_VERTEX));
 542         }
 543         else {
 544           // ??? geompy.kind.FACE  nb_edges nb_vertices _surface_type_id_
 545           // (+) geompy.kind.FACE  nb_edges nb_vertices
 546
 547           theIntegers->Append(anInfo.NbSubShapes(TopAbs_EDGE));
 548           theIntegers->Append(anInfo.NbSubShapes(TopAbs_VERTEX));
 549         }
 550       }
 551     }
 552     break;
 553
 554   case TopAbs_EDGE:
 555     {
 556       aKind = SK_EDGE;
 557
 558       GEOMAlgo_KindOfName aKN = anInfo.KindOfName();
 559       switch (aKN) {
 560       case GEOMAlgo_KN_CIRCLE:
 561         {
 562           // (+) geompy.kind.CIRCLE  xc yc zc  dx dy dz  R
 563           aKind = SK_CIRCLE;
 564
 565           gp_Pnt aC = anInfo.Location();
 566           theDoubles->Append(aC.X());
 567           theDoubles->Append(aC.Y());
 568           theDoubles->Append(aC.Z());
 569
 570           gp_Ax3 anAx3 = anInfo.Position();
 571           gp_Dir aD = anAx3.Direction();
 572           theDoubles->Append(aD.X());
 573           theDoubles->Append(aD.Y());
 574           theDoubles->Append(aD.Z());
 575
 576           theDoubles->Append(anInfo.Radius1());
 577         }
 578         break;
 579       case GEOMAlgo_KN_ARCCIRCLE:
 580         {
 581           // (+) geompy.kind.ARC_CIRCLE  xc yc zc  dx dy dz  R  x1 y1 z1  x2 y2 z2
 582           aKind = SK_ARC_CIRCLE;
 583
 584           gp_Pnt aC = anInfo.Location();
 585           theDoubles->Append(aC.X());
 586           theDoubles->Append(aC.Y());
 587           theDoubles->Append(aC.Z());
 588
 589           gp_Ax3 anAx3 = anInfo.Position();
 590           gp_Dir aD = anAx3.Direction();
 591           theDoubles->Append(aD.X());
 592           theDoubles->Append(aD.Y());
 593           theDoubles->Append(aD.Z());
 594
 595           theDoubles->Append(anInfo.Radius1());
 596
 597           gp_Pnt aP1 = anInfo.Pnt1();
 598           theDoubles->Append(aP1.X());
 599           theDoubles->Append(aP1.Y());
 600           theDoubles->Append(aP1.Z());
 601
 602           gp_Pnt aP2 = anInfo.Pnt2();
 603           theDoubles->Append(aP2.X());
 604           theDoubles->Append(aP2.Y());
 605           theDoubles->Append(aP2.Z());
 606         }
 607         break;
 608       case GEOMAlgo_KN_ELLIPSE:
 609         {
 610           // (+) geompy.kind.ELLIPSE  xc yc zc  dx dy dz  R_1 R_2
 611           aKind = SK_ELLIPSE;
 612
 613           gp_Pnt aC = anInfo.Location();
 614           theDoubles->Append(aC.X());
 615           theDoubles->Append(aC.Y());
 616           theDoubles->Append(aC.Z());
 617
 618           gp_Ax3 anAx3 = anInfo.Position();
 619           gp_Dir aD = anAx3.Direction();
 620           theDoubles->Append(aD.X());
 621           theDoubles->Append(aD.Y());
 622           theDoubles->Append(aD.Z());
 623
 624           theDoubles->Append(anInfo.Radius1());
 625           theDoubles->Append(anInfo.Radius2());
 626         }
 627         break;
 628       case GEOMAlgo_KN_ARCELLIPSE:
 629         {
 630           // (+) geompy.kind.ARC_ELLIPSE  xc yc zc  dx dy dz  R_1 R_2  x1 y1 z1  x2 y2 z2
 631           aKind = SK_ARC_ELLIPSE;
 632
 633           gp_Pnt aC = anInfo.Location();
 634           theDoubles->Append(aC.X());
 635           theDoubles->Append(aC.Y());
 636           theDoubles->Append(aC.Z());
 637
 638           gp_Ax3 anAx3 = anInfo.Position();
 639           gp_Dir aD = anAx3.Direction();
 640           theDoubles->Append(aD.X());
 641           theDoubles->Append(aD.Y());
 642           theDoubles->Append(aD.Z());
 643
 644           theDoubles->Append(anInfo.Radius1());
 645           theDoubles->Append(anInfo.Radius2());
 646
 647           gp_Pnt aP1 = anInfo.Pnt1();
 648           theDoubles->Append(aP1.X());
 649           theDoubles->Append(aP1.Y());
 650           theDoubles->Append(aP1.Z());
 651
 652           gp_Pnt aP2 = anInfo.Pnt2();
 653           theDoubles->Append(aP2.X());
 654           theDoubles->Append(aP2.Y());
 655           theDoubles->Append(aP2.Z());
 656         }
 657         break;
 658       case GEOMAlgo_KN_LINE:
 659         {
 660           // ??? geompy.kind.LINE  x1 y1 z1  x2 y2 z2
 661           // (+) geompy.kind.LINE  x1 y1 z1  dx dy dz
 662           aKind = SK_LINE;
 663
 664           gp_Pnt aO = anInfo.Location();
 665           theDoubles->Append(aO.X());
 666           theDoubles->Append(aO.Y());
 667           theDoubles->Append(aO.Z());
 668
 669           gp_Dir aD = anInfo.Direction();
 670           theDoubles->Append(aD.X());
 671           theDoubles->Append(aD.Y());
 672           theDoubles->Append(aD.Z());
 673         }
 674         break;
 675       case GEOMAlgo_KN_SEGMENT:
 676         {
 677           // (+) geompy.kind.SEGMENT  x1 y1 z1  x2 y2 z2
 678           aKind = SK_SEGMENT;
 679
 680           gp_Pnt aP1 = anInfo.Pnt1();
 681           theDoubles->Append(aP1.X());
 682           theDoubles->Append(aP1.Y());
 683           theDoubles->Append(aP1.Z());
 684
 685           gp_Pnt aP2 = anInfo.Pnt2();
 686           theDoubles->Append(aP2.X());
 687           theDoubles->Append(aP2.Y());
 688           theDoubles->Append(aP2.Z());
 689         }
 690         break;
 691       default:
 692         // ??? geompy.kind.EDGE  nb_vertices _curve_type_id_
 693         // (+) geompy.kind.EDGE  nb_vertices
 694         theIntegers->Append(anInfo.NbSubShapes(TopAbs_VERTEX));
 695       }
 696     }
 697     break;
 698
 699   case TopAbs_VERTEX:
 700     {
 701       // (+) geompy.kind.VERTEX  x y z
 702       aKind = SK_VERTEX;
 703
 704       gp_Pnt aP = anInfo.Location();
 705       theDoubles->Append(aP.X());
 706       theDoubles->Append(aP.Y());
 707       theDoubles->Append(aP.Z());
 708     }
 709     break;
 710   }
 711
 712   SetErrorCode(OK);
 713   return aKind;
 714 }
 715
 716 //=============================================================================
 717 /*!
 718  *  GetPosition
 719  */
 720 //=============================================================================
 721 void GEOMImpl_IMeasureOperations::GetPosition
 722                    (Handle(GEOM_Object) theShape,
 723                     Standard_Real& Ox, Standard_Real& Oy, Standard_Real& Oz,
 724                     Standard_Real& Zx, Standard_Real& Zy, Standard_Real& Zz,
 725                     Standard_Real& Xx, Standard_Real& Xy, Standard_Real& Xz)
 726 {
 727   SetErrorCode(KO);
 728
 729   //Set default values: global CS
 730   Ox = Oy = Oz = Zx = Zy = Xy = Xz = 0.;
 731   Zz = Xx = 1.;
 732
 733   if (theShape.IsNull()) return;
 734
 735   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
 736   if (aRefShape.IsNull()) return;
 737
 738   TopoDS_Shape aShape = aRefShape->GetValue();
 739   if (aShape.IsNull()) {
 740     SetErrorCode("The Objects has NULL Shape");
 741     return;
 742   }
 743
 744   try {
 745     OCC_CATCH_SIGNALS;
 746
 747     gp_Ax3 anAx3 = GEOMUtils::GetPosition(aShape);
 748
 749     gp_Pnt anOri = anAx3.Location();
 750     gp_Dir aDirZ = anAx3.Direction();
 751     gp_Dir aDirX = anAx3.XDirection();
 752
 753     // Output values
 754     anOri.Coord(Ox, Oy, Oz);
 755     aDirZ.Coord(Zx, Zy, Zz);
 756     aDirX.Coord(Xx, Xy, Xz);
 757   }
 758   catch (Standard_Failure) {
 759     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 760     SetErrorCode(aFail->GetMessageString());
 761     return;
 762   }
 763
 764   SetErrorCode(OK);
 765 }
 766
 767 //=============================================================================
 768 /*!
 769  *  GetCentreOfMass
 770  */
 771 //=============================================================================
 772 Handle(GEOM_Object) GEOMImpl_IMeasureOperations::GetCentreOfMass
 773                                                 (Handle(GEOM_Object) theShape)
 774 {
 775   SetErrorCode(KO);
 776
 777   if (theShape.IsNull()) return NULL;
 778
 779   //Add a new CentreOfMass object
 780   Handle(GEOM_Object) aCDG = GetEngine()->AddObject(GetDocID(), GEOM_CDG);
 781
 782   //Add a new CentreOfMass function
 783   Handle(GEOM_Function) aFunction =
 784     aCDG->AddFunction(GEOMImpl_MeasureDriver::GetID(), CDG_MEASURE);
 785   if (aFunction.IsNull()) return NULL;
 786
 787   //Check if the function is set correctly
 788   if (aFunction->GetDriverGUID() != GEOMImpl_MeasureDriver::GetID()) return NULL;
 789
 790   GEOMImpl_IMeasure aCI (aFunction);
 791
 792   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
 793   if (aRefShape.IsNull()) return NULL;
 794
 795   aCI.SetBase(aRefShape);
 796
 797   //Compute the CentreOfMass value
 798   try {
 799     OCC_CATCH_SIGNALS;
 800     if (!GetSolver()->ComputeFunction(aFunction)) {
 801       SetErrorCode("Measure driver failed to compute centre of mass");
 802       return NULL;
 803     }
 804   }
 805   catch (Standard_Failure) {
 806     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 807     SetErrorCode(aFail->GetMessageString());
 808     return NULL;
 809   }
 810
 811   //Make a Python command
 812   GEOM::TPythonDump(aFunction) << aCDG << " = geompy.MakeCDG(" << theShape << ")";
 813
 814   SetErrorCode(OK);
 815   return aCDG;
 816 }
 817
 818 //=============================================================================
 819 /*!
 820  *  GetVertexByIndex
 821  */
 822 //=============================================================================
 823 Handle(GEOM_Object) GEOMImpl_IMeasureOperations::GetVertexByIndex
 824                                                 (Handle(GEOM_Object) theShape,
 825                                                  Standard_Integer theIndex)
 826 {
 827   SetErrorCode(KO);
 828
 829   if (theShape.IsNull()) return NULL;
 830
 831   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
 832   if (aRefShape.IsNull()) return NULL;
 833
 834   //Add a new Vertex object
 835   Handle(GEOM_Object) aVertex = GetEngine()->AddObject(GetDocID(), GEOM_POINT);
 836
 837   //Add a function
 838   Handle(GEOM_Function) aFunction =
 839     aVertex->AddFunction(GEOMImpl_MeasureDriver::GetID(), VERTEX_BY_INDEX);
 840   if (aFunction.IsNull()) return NULL;
 841
 842   //Check if the function is set correctly
 843   if (aFunction->GetDriverGUID() != GEOMImpl_MeasureDriver::GetID()) return NULL;
 844
 845   GEOMImpl_IMeasure aCI (aFunction);
 846   aCI.SetBase(aRefShape);
 847   aCI.SetIndex(theIndex);
 848
 849   //Compute
 850   try {
 851     OCC_CATCH_SIGNALS;
 852     if (!GetSolver()->ComputeFunction(aFunction)) {
 853       SetErrorCode("Vertex by index driver failed.");
 854       return NULL;
 855     }
 856   }
 857   catch (Standard_Failure) {
 858     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 859     SetErrorCode(aFail->GetMessageString());
 860     return NULL;
 861   }
 862
 863   //Make a Python command
 864   GEOM::TPythonDump(aFunction) << aVertex << " = geompy.GetVertexByIndex(" << theShape << ", " << theIndex << ")";
 865
 866   SetErrorCode(OK);
 867   return aVertex;
 868 }
 869
 870 //=============================================================================
 871 /*!
 872  *  GetNormal
 873  */
 874 //=============================================================================
 875 Handle(GEOM_Object) GEOMImpl_IMeasureOperations::GetNormal
 876                                          (Handle(GEOM_Object) theFace,
 877                                           Handle(GEOM_Object) theOptionalPoint)
 878 {
 879   SetErrorCode(KO);
 880
 881   if (theFace.IsNull()) return NULL;
 882
 883   //Add a new Normale object
 884   Handle(GEOM_Object) aNorm = GetEngine()->AddObject(GetDocID(), GEOM_VECTOR);
 885
 886   //Add a new Normale function
 887   Handle(GEOM_Function) aFunction =
 888     aNorm->AddFunction(GEOMImpl_MeasureDriver::GetID(), VECTOR_FACE_NORMALE);
 889   if (aFunction.IsNull()) return NULL;
 890
 891   //Check if the function is set correctly
 892   if (aFunction->GetDriverGUID() != GEOMImpl_MeasureDriver::GetID()) return NULL;
 893
 894   GEOMImpl_IMeasure aCI (aFunction);
 895
 896   Handle(GEOM_Function) aFace = theFace->GetLastFunction();
 897   if (aFace.IsNull()) return NULL;
 898
 899   aCI.SetBase(aFace);
 900
 901   if (!theOptionalPoint.IsNull()) {
 902     Handle(GEOM_Function) anOptPnt = theOptionalPoint->GetLastFunction();
 903     aCI.SetPoint(anOptPnt);
 904   }
 905
 906   //Compute the Normale value
 907   try {
 908     OCC_CATCH_SIGNALS;
 909     if (!GetSolver()->ComputeFunction(aFunction)) {
 910       SetErrorCode("Measure driver failed to compute normake of face");
 911       return NULL;
 912     }
 913   }
 914   catch (Standard_Failure) {
 915     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 916     SetErrorCode(aFail->GetMessageString());
 917     return NULL;
 918   }
 919
 920   //Make a Python command
 921   GEOM::TPythonDump pd (aFunction);
 922   pd << aNorm << " = geompy.GetNormal(" << theFace;
 923   if (!theOptionalPoint.IsNull()) {
 924     pd << ", " << theOptionalPoint;
 925   }
 926   pd << ")";
 927
 928   SetErrorCode(OK);
 929   return aNorm;
 930 }
 931
 932 //=============================================================================
 933 /*!
 934  *  GetBasicProperties
 935  */
 936 //=============================================================================
 937 void GEOMImpl_IMeasureOperations::GetBasicProperties (Handle(GEOM_Object) theShape,
 938                                                       Standard_Real& theLength,
 939                                                       Standard_Real& theSurfArea,
 940                                                       Standard_Real& theVolume)
 941 {
 942   SetErrorCode(KO);
 943
 944   if (theShape.IsNull()) return;
 945
 946   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
 947   if (aRefShape.IsNull()) return;
 948
 949   TopoDS_Shape aShape = aRefShape->GetValue();
 950   if (aShape.IsNull()) {
 951     SetErrorCode("The Objects has NULL Shape");
 952     return;
 953   }
 954
 955   //Compute the parameters
 956   GProp_GProps LProps, SProps;
 957   try {
 958     OCC_CATCH_SIGNALS;
 959     BRepGProp::LinearProperties(aShape, LProps);
 960     theLength = LProps.Mass();
 961
 962     BRepGProp::SurfaceProperties(aShape, SProps);
 963     theSurfArea = SProps.Mass();
 964
 965     theVolume = 0.0;
 966     if (aShape.ShapeType() < TopAbs_SHELL) {
 967       for (TopExp_Explorer Exp (aShape, TopAbs_SOLID); Exp.More(); Exp.Next()) {
 968         GProp_GProps VProps;
 969         BRepGProp::VolumeProperties(Exp.Current(), VProps);
 970         theVolume += VProps.Mass();
 971       }
 972     }
 973   }
 974   catch (Standard_Failure) {
 975     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 976     SetErrorCode(aFail->GetMessageString());
 977     return;
 978   }
 979
 980   SetErrorCode(OK);
 981 }
 982
 983 //=============================================================================
 984 /*!
 985  *  GetInertia
 986  */
 987 //=============================================================================
 988 void GEOMImpl_IMeasureOperations::GetInertia
 989                    (Handle(GEOM_Object) theShape,
 990                     Standard_Real& I11, Standard_Real& I12, Standard_Real& I13,
 991                     Standard_Real& I21, Standard_Real& I22, Standard_Real& I23,
 992                     Standard_Real& I31, Standard_Real& I32, Standard_Real& I33,
 993                     Standard_Real& Ix , Standard_Real& Iy , Standard_Real& Iz)
 994 {
 995   SetErrorCode(KO);
 996
 997   if (theShape.IsNull()) return;
 998
 999   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1000   if (aRefShape.IsNull()) return;
1001
1002   TopoDS_Shape aShape = aRefShape->GetValue();
1003   if (aShape.IsNull()) {
1004     SetErrorCode("The Objects has NULL Shape");
1005     return;
1006   }
1007
1008   //Compute the parameters
1009   GProp_GProps System;
1010
1011   try {
1012     OCC_CATCH_SIGNALS;
1013     if (aShape.ShapeType() == TopAbs_VERTEX ||
1014         aShape.ShapeType() == TopAbs_EDGE ||
1015         aShape.ShapeType() == TopAbs_WIRE) {
1016       BRepGProp::LinearProperties(aShape, System);
1017     } else if (aShape.ShapeType() == TopAbs_FACE ||
1018                aShape.ShapeType() == TopAbs_SHELL) {
1019       BRepGProp::SurfaceProperties(aShape, System);
1020     } else {
1021       BRepGProp::VolumeProperties(aShape, System);
1022     }
1023     gp_Mat I = System.MatrixOfInertia();
1024
1025     I11 = I(1,1);
1026     I12 = I(1,2);
1027     I13 = I(1,3);
1028
1029     I21 = I(2,1);
1030     I22 = I(2,2);
1031     I23 = I(2,3);
1032
1033     I31 = I(3,1);
1034     I32 = I(3,2);
1035     I33 = I(3,3);
1036
1037     GProp_PrincipalProps Pr = System.PrincipalProperties();
1038     Pr.Moments(Ix,Iy,Iz);
1039   }
1040   catch (Standard_Failure) {
1041     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1042     SetErrorCode(aFail->GetMessageString());
1043     return;
1044   }
1045
1046   SetErrorCode(OK);
1047 }
1048
1049 //=============================================================================
1050 /*!
1051  *  GetBoundingBox
1052  */
1053 //=============================================================================
1054 void GEOMImpl_IMeasureOperations::GetBoundingBox
1055                                      (Handle(GEOM_Object) theShape,
1056                                       const Standard_Boolean precise,
1057                                       Standard_Real& Xmin, Standard_Real& Xmax,
1058                                       Standard_Real& Ymin, Standard_Real& Ymax,
1059                                       Standard_Real& Zmin, Standard_Real& Zmax)
1060 {
1061   SetErrorCode(KO);
1062
1063   if (theShape.IsNull()) return;
1064
1065   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1066   if (aRefShape.IsNull()) return;
1067
1068   TopoDS_Shape aShape = aRefShape->GetValue();
1069   if (aShape.IsNull()) {
1070     SetErrorCode("The Objects has NULL Shape");
1071     return;
1072   }
1073
1074   //Compute the parameters
1075   Bnd_Box B;
1076
1077   try {
1078     OCC_CATCH_SIGNALS;
1079     BRepBuilderAPI_Copy aCopyTool (aShape);
1080     if (!aCopyTool.IsDone()) {
1081       SetErrorCode("GetBoundingBox Error: Bad shape detected");
1082       return;
1083     }
1084
1085     aShape = aCopyTool.Shape();
1086
1087     // remove triangulation to obtain more exact boundaries
1088     BRepTools::Clean(aShape);
1089
1090     BRepBndLib::Add(aShape, B);
1091
1092     if (precise) {
1093       if (!GEOMUtils::PreciseBoundingBox(aShape, B)) {
1094         SetErrorCode("GetBoundingBox Error: Bounding box cannot be precised");
1095         return;
1096       }
1097     }
1098
1099     B.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
1100   }
1101   catch (Standard_Failure) {
1102     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1103     SetErrorCode(aFail->GetMessageString());
1104     return;
1105   }
1106
1107   SetErrorCode(OK);
1108 }
1109
1110 //=============================================================================
1111 /*!
1112  *  GetBoundingBox
1113  */
1114 //=============================================================================
1115 Handle(GEOM_Object) GEOMImpl_IMeasureOperations::GetBoundingBox
1116                                                 (Handle(GEOM_Object) theShape,
1117                                                  const Standard_Boolean precise)
1118 {
1119   SetErrorCode(KO);
1120
1121   if (theShape.IsNull()) return NULL;
1122
1123   //Add a new BoundingBox object
1124   Handle(GEOM_Object) aBnd = GetEngine()->AddObject(GetDocID(), GEOM_BOX);
1125
1126   //Add a new BoundingBox function
1127   const int aType = (precise ? BND_BOX_MEASURE_PRECISE : BND_BOX_MEASURE);
1128   Handle(GEOM_Function) aFunction =
1129     aBnd->AddFunction(GEOMImpl_MeasureDriver::GetID(), aType);
1130   if (aFunction.IsNull()) return NULL;
1131
1132   //Check if the function is set correctly
1133   if (aFunction->GetDriverGUID() != GEOMImpl_MeasureDriver::GetID()) return NULL;
1134
1135   GEOMImpl_IMeasure aCI (aFunction);
1136
1137   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1138   if (aRefShape.IsNull()) return NULL;
1139
1140   aCI.SetBase(aRefShape);
1141
1142   //Compute the BoundingBox value
1143   try {
1144     OCC_CATCH_SIGNALS;
1145     if (!GetSolver()->ComputeFunction(aFunction)) {
1146       SetErrorCode("Measure driver failed to compute a bounding box");
1147       return NULL;
1148     }
1149   }
1150   catch (Standard_Failure) {
1151     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1152     SetErrorCode(aFail->GetMessageString());
1153     return NULL;
1154   }
1155
1156   //Make a Python command
1157   GEOM::TPythonDump aPd(aFunction);
1158
1159   aPd << aBnd << " = geompy.MakeBoundingBox(" << theShape;
1160
1161   if (precise) {
1162     aPd << ", True";
1163   }
1164
1165   aPd << ")";
1166
1167   SetErrorCode(OK);
1168   return aBnd;
1169 }
1170
1171 //=============================================================================
1172 /*!
1173  *  GetTolerance
1174  */
1175 //=============================================================================
1176 void GEOMImpl_IMeasureOperations::GetTolerance
1177                                (Handle(GEOM_Object) theShape,
1178                                 Standard_Real& FaceMin, Standard_Real& FaceMax,
1179                                 Standard_Real& EdgeMin, Standard_Real& EdgeMax,
1180                                 Standard_Real& VertMin, Standard_Real& VertMax)
1181 {
1182   SetErrorCode(KO);
1183
1184   if (theShape.IsNull()) return;
1185
1186   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1187   if (aRefShape.IsNull()) return;
1188
1189   TopoDS_Shape aShape = aRefShape->GetValue();
1190   if (aShape.IsNull()) {
1191     SetErrorCode("The Objects has NULL Shape");
1192     return;
1193   }
1194
1195   //Compute the parameters
1196   Standard_Real T;
1197   FaceMin = EdgeMin = VertMin = RealLast();
1198   FaceMax = EdgeMax = VertMax = -RealLast();
1199
1200   try {
1201     OCC_CATCH_SIGNALS;
1202     for (TopExp_Explorer ExF (aShape, TopAbs_FACE); ExF.More(); ExF.Next()) {
1203       TopoDS_Face Face = TopoDS::Face(ExF.Current());
1204       T = BRep_Tool::Tolerance(Face);
1205       if (T > FaceMax)
1206         FaceMax = T;
1207       if (T < FaceMin)
1208         FaceMin = T;
1209     }
1210     for (TopExp_Explorer ExE (aShape, TopAbs_EDGE); ExE.More(); ExE.Next()) {
1211       TopoDS_Edge Edge = TopoDS::Edge(ExE.Current());
1212       T = BRep_Tool::Tolerance(Edge);
1213       if (T > EdgeMax)
1214         EdgeMax = T;
1215       if (T < EdgeMin)
1216         EdgeMin = T;
1217     }
1218     for (TopExp_Explorer ExV (aShape, TopAbs_VERTEX); ExV.More(); ExV.Next()) {
1219       TopoDS_Vertex Vertex = TopoDS::Vertex(ExV.Current());
1220       T = BRep_Tool::Tolerance(Vertex);
1221       if (T > VertMax)
1222         VertMax = T;
1223       if (T < VertMin)
1224         VertMin = T;
1225     }
1226   }
1227   catch (Standard_Failure) {
1228     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1229     SetErrorCode(aFail->GetMessageString());
1230     return;
1231   }
1232
1233   SetErrorCode(OK);
1234 }
1235
1236 //=============================================================================
1237 /*!
1238  *  CheckShape
1239  */
1240 //=============================================================================
1241 bool GEOMImpl_IMeasureOperations::CheckShape (Handle(GEOM_Object)     theShape,
1242                                               const Standard_Boolean  theIsCheckGeom,
1243                                               std::list<ShapeError>  &theErrors)
1244 {
1245   SetErrorCode(KO);
1246   theErrors.clear();
1247
1248   if (theShape.IsNull()) return false;
1249
1250   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1251   if (aRefShape.IsNull()) return false;
1252
1253   TopoDS_Shape aShape = aRefShape->GetValue();
1254   if (aShape.IsNull()) {
1255     SetErrorCode("The Objects has NULL Shape");
1256     return false;
1257   }
1258
1259   //Compute the parameters
1260   bool isValid = false;
1261   try {
1262     OCC_CATCH_SIGNALS;
1263     BRepCheck_Analyzer ana (aShape, theIsCheckGeom);
1264     if (ana.IsValid()) {
1265       isValid = true;
1266     } else {
1267       FillErrors(ana, aShape, theErrors);
1268     }
1269   }
1270   catch (Standard_Failure) {
1271     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1272     SetErrorCode(aFail->GetMessageString());
1273     return false;
1274   }
1275
1276   SetErrorCode(OK);
1277   return isValid;
1278 }
1279
1280 //=============================================================================
1281 /*!
1282  *  PrintShapeErrors
1283  */
1284 //=============================================================================
1285 TCollection_AsciiString GEOMImpl_IMeasureOperations::PrintShapeErrors
1286                                  (Handle(GEOM_Object)          theShape,
1287                                   const std::list<ShapeError> &theErrors)
1288 {
1289   TCollection_AsciiString aDump;
1290
1291   if (theShape.IsNull()) {
1292     return aDump;
1293   }
1294
1295   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1296
1297   if (aRefShape.IsNull()) {
1298     return aDump;
1299   }
1300
1301   TopoDS_Shape aShape = aRefShape->GetValue();
1302
1303   if (aShape.IsNull()) {
1304     SetErrorCode("The Objects has NULL Shape");
1305     return aDump;
1306   }
1307
1308   if (!theErrors.empty()) {
1309     // The shape is not valid. Prepare errors for dump.
1310     TopTools_IndexedMapOfShape anIndices;
1311     std::list<ShapeError>::const_iterator anIter = theErrors.begin();
1312     Standard_Integer nbv, nbe, nbw, nbf, nbs, nbo;
1313     nbv = nbe = nbw = nbf = nbs = nbo = 0;
1314
1315     // Map sub-shapes and their indices
1316     TopExp::MapShapes(aShape, anIndices);
1317
1318     const Standard_Integer aNbSubShapes = anIndices.Extent();
1319     TColStd_MapOfInteger   aMapPbInd;
1320
1321     aDump += " -- The Shape has problems :\n";
1322     aDump += "  Check                                    Count\n";
1323     aDump += " ------------------------------------------------\n";
1324
1325     for (; anIter != theErrors.end(); anIter++) {
1326       Standard_Integer aNbShapes = anIter->incriminated.size();
1327
1328       switch(anIter->error) {
1329       case BRepCheck_InvalidPointOnCurve:
1330         aDump += "  Invalid Point on Curve ................... ";
1331         break;
1332       case BRepCheck_InvalidPointOnCurveOnSurface:
1333         aDump += "  Invalid Point on CurveOnSurface .......... ";
1334         break;
1335       case BRepCheck_InvalidPointOnSurface:
1336         aDump += "  Invalid Point on Surface ................. ";
1337         break;
1338       case BRepCheck_No3DCurve:
1339         aDump += "  No 3D Curve .............................. ";
1340         break;
1341       case BRepCheck_Multiple3DCurve:
1342         aDump += "  Multiple 3D Curve ........................ ";
1343         break;
1344       case BRepCheck_Invalid3DCurve:
1345         aDump += "  Invalid 3D Curve ......................... ";
1346         break;
1347       case BRepCheck_NoCurveOnSurface:
1348         aDump += "  No Curve on Surface ...................... ";
1349         break;
1350       case BRepCheck_InvalidCurveOnSurface:
1351         aDump += "  Invalid Curve on Surface ................. ";
1352         break;
1353       case BRepCheck_InvalidCurveOnClosedSurface:
1354         aDump += "  Invalid Curve on closed Surface .......... ";
1355         break;
1356       case BRepCheck_InvalidSameRangeFlag:
1357         aDump += "  Invalid SameRange Flag ................... ";
1358         break;
1359       case BRepCheck_InvalidSameParameterFlag:
1360         aDump += "  Invalid SameParameter Flag ............... ";
1361         break;
1362       case BRepCheck_InvalidDegeneratedFlag:
1363         aDump += "  Invalid Degenerated Flag ................. ";
1364         break;
1365       case BRepCheck_FreeEdge:
1366         aDump += "  Free Edge ................................ ";
1367         break;
1368       case BRepCheck_InvalidMultiConnexity:
1369         aDump += "  Invalid MultiConnexity ................... ";
1370         break;
1371       case BRepCheck_InvalidRange:
1372         aDump += "  Invalid Range ............................ ";
1373         break;
1374       case BRepCheck_EmptyWire:
1375         aDump += "  Empty Wire ............................... ";
1376         break;
1377       case BRepCheck_RedundantEdge:
1378         aDump += "  Redundant Edge ........................... ";
1379         break;
1380       case BRepCheck_SelfIntersectingWire:
1381         aDump += "  Self Intersecting Wire ................... ";
1382         break;
1383       case BRepCheck_NoSurface:
1384         aDump += "  No Surface ............................... ";
1385         break;
1386       case BRepCheck_InvalidWire:
1387         aDump += "  Invalid Wire ............................. ";
1388         break;
1389       case BRepCheck_RedundantWire:
1390         aDump += "  Redundant Wire ........................... ";
1391         break;
1392       case BRepCheck_IntersectingWires:
1393         aDump += "  Intersecting Wires ....................... ";
1394         break;
1395       case BRepCheck_InvalidImbricationOfWires:
1396         aDump += "  Invalid Imbrication of Wires ............. ";
1397         break;
1398       case BRepCheck_EmptyShell:
1399         aDump += "  Empty Shell .............................. ";
1400         break;
1401       case BRepCheck_RedundantFace:
1402         aDump += "  Redundant Face ........................... ";
1403         break;
1404       case BRepCheck_UnorientableShape:
1405         aDump += "  Unorientable Shape ....................... ";
1406         break;
1407       case BRepCheck_NotClosed:
1408         aDump += "  Not Closed ............................... ";
1409         break;
1410       case BRepCheck_NotConnected:
1411         aDump += "  Not Connected ............................ ";
1412         break;
1413       case BRepCheck_SubshapeNotInShape:
1414         aDump += "  Sub-shape not in Shape ................... ";
1415         break;
1416       case BRepCheck_BadOrientation:
1417         aDump += "  Bad Orientation .......................... ";
1418         break;
1419       case BRepCheck_BadOrientationOfSubshape:
1420         aDump += "  Bad Orientation of Sub-shape ............. ";
1421         break;
1422       case BRepCheck_InvalidToleranceValue:
1423         aDump += "  Invalid Tolerance Value .................. ";
1424         break;
1425       case BRepCheck_CheckFail:
1426         aDump += "  Check Shape Failure ...................... ";
1427         break;
1428       default:
1429         break;
1430       }
1431
1432       aDump += TCollection_AsciiString(aNbShapes) + "\n";
1433
1434       // Count types of shape.
1435       std::list<int>::const_iterator aShIter = anIter->incriminated.begin();
1436
1437       for (; aShIter != anIter->incriminated.end(); aShIter++) {
1438         const Standard_Integer anIndex = *aShIter;
1439
1440         if (anIndex > 0 && anIndex <= aNbSubShapes && aMapPbInd.Add(anIndex)) {
1441           const TopoDS_Shape     &aSubShape = anIndices.FindKey(anIndex);
1442           const TopAbs_ShapeEnum  aType     = aSubShape.ShapeType();
1443
1444           switch (aType) {
1445             case TopAbs_VERTEX : nbv++; break;
1446             case TopAbs_EDGE   : nbe++; break;
1447             case TopAbs_WIRE   : nbw++; break;
1448             case TopAbs_FACE   : nbf++; break;
1449             case TopAbs_SHELL  : nbs++; break;
1450             case TopAbs_SOLID  : nbo++; break;
1451             default            : break;
1452           }
1453         }
1454       }
1455     }
1456
1457     const Standard_Integer aNbFaultyShapes = nbv + nbe + nbw + nbf + nbs + nbo;
1458     aDump += " ------------------------------------------------\n";
1459     aDump += "*** Shapes with problems : ";
1460     aDump += TCollection_AsciiString(aNbFaultyShapes) + "\n";
1461
1462     if (nbv > 0) {
1463       aDump += "VERTEX : ";
1464       if (nbv < 10) aDump += " ";
1465       aDump += TCollection_AsciiString(nbv) + "\n";
1466     }
1467     if (nbe > 0) {
1468       aDump += "EDGE   : ";
1469       if (nbe < 10) aDump += " ";
1470       aDump += TCollection_AsciiString(nbe) + "\n";
1471     }
1472     if (nbw > 0) {
1473       aDump += "WIRE   : ";
1474       if (nbw < 10) aDump += " ";
1475       aDump += TCollection_AsciiString(nbw) + "\n";
1476     }
1477     if (nbf > 0) {
1478       aDump += "FACE   : ";
1479       if (nbf < 10) aDump += " ";
1480       aDump += TCollection_AsciiString(nbf) + "\n";
1481     }
1482     if (nbs > 0) {
1483       aDump += "SHELL  : ";
1484       if (nbs < 10) aDump += " ";
1485       aDump += TCollection_AsciiString(nbs) + "\n";
1486     }
1487     if (nbo > 0) {
1488       aDump += "SOLID  : ";
1489       if (nbo < 10) aDump += " ";
1490       aDump += TCollection_AsciiString(nbo) + "\n";
1491     }
1492   }
1493
1494   return aDump;
1495 }
1496
1497 //=============================================================================
1498 /*!
1499  *  CheckSelfIntersections
1500  */
1501 //=============================================================================
1502 bool GEOMImpl_IMeasureOperations::CheckSelfIntersections
1503                          (Handle(GEOM_Object)                 theShape,
1504                           Handle(TColStd_HSequenceOfInteger)& theIntersections)
1505 {
1506   SetErrorCode(KO);
1507   bool isGood = false;
1508
1509   if (theIntersections.IsNull())
1510     theIntersections = new TColStd_HSequenceOfInteger;
1511   else
1512     theIntersections->Clear();
1513
1514   if (theShape.IsNull())
1515     return isGood;
1516
1517   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1518   if (aRefShape.IsNull()) return isGood;
1519
1520   TopoDS_Shape aShape = aRefShape->GetValue();
1521   if (aShape.IsNull()) return isGood;
1522
1523   // 0. Prepare data
1524   TopoDS_Shape aScopy;
1525   //
1526   GEOMAlgo_AlgoTools::CopyShape(aShape, aScopy);
1527   //
1528   // Map sub-shapes and their indices
1529   TopTools_IndexedMapOfShape anIndices;
1530   TopExp::MapShapes(aScopy, anIndices);
1531
1532   BOPCol_ListOfShape aLCS;
1533   aLCS.Append(aScopy);
1534   //
1535   BOPAlgo_CheckerSI aCSI; // checker of self-interferences
1536   aCSI.SetArguments(aLCS);
1537
1538   // 1. Launch the checker
1539   aCSI.Perform();
1540   Standard_Integer iErr = aCSI.ErrorStatus();
1541
1542   isGood = true;
1543   //
1544   Standard_Integer aNbS, n1, n2;
1545   BOPDS_MapIteratorMapOfPassKey aItMPK;
1546   //
1547   // 2. Take the shapes from DS
1548   const BOPDS_DS& aDS = aCSI.DS();
1549   aNbS=aDS.NbShapes();
1550   //
1551   // 3. Get the pairs of interfered shapes
1552   const BOPDS_MapOfPassKey& aMPK=aDS.Interferences();
1553   aItMPK.Initialize(aMPK);
1554   for (; aItMPK.More(); aItMPK.Next()) {
1555     const BOPDS_PassKey& aPK=aItMPK.Value();
1556     aPK.Ids(n1, n2);
1557     //
1558     if (n1 > aNbS || n2 > aNbS){
1559       return false; // Error
1560     }
1561     const TopoDS_Shape& aS1 = aDS.Shape(n1);
1562     const TopoDS_Shape& aS2 = aDS.Shape(n2);
1563
1564     theIntersections->Append(anIndices.FindIndex(aS1));
1565     theIntersections->Append(anIndices.FindIndex(aS2));
1566     isGood = false;
1567   }
1568
1569   if (!iErr) {
1570     SetErrorCode(OK);
1571   }
1572
1573   return isGood;
1574 }
1575
1576 //=============================================================================
1577 /*!
1578  *  IsGoodForSolid
1579  */
1580 //=============================================================================
1581 TCollection_AsciiString GEOMImpl_IMeasureOperations::IsGoodForSolid (Handle(GEOM_Object) theShape)
1582 {
1583   SetErrorCode(KO);
1584
1585   TCollection_AsciiString aRes = "";
1586
1587   if (theShape.IsNull()) {
1588     aRes = "WRN_NULL_OBJECT_OR_SHAPE";
1589   }
1590   else {
1591     Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1592     if (aRefShape.IsNull()) {
1593       aRes = "WRN_NULL_OBJECT_OR_SHAPE";
1594     }
1595     else {
1596       TopoDS_Shape aShape = aRefShape->GetValue();
1597       if (aShape.IsNull()) {
1598         aRes = "WRN_NULL_OBJECT_OR_SHAPE";
1599       }
1600       else {
1601         if (aShape.ShapeType() == TopAbs_COMPOUND) {
1602           TopoDS_Iterator It (aShape, Standard_True, Standard_True);
1603           if (It.More()) aShape = It.Value();
1604         }
1605         if (aShape.ShapeType() == TopAbs_SHELL) {
1606           BRepCheck_Shell chkShell (TopoDS::Shell(aShape));
1607           if (chkShell.Closed() == BRepCheck_NotClosed) {
1608             aRes = "WRN_SHAPE_UNCLOSED";
1609           }
1610         }
1611         else {
1612           aRes = "WRN_SHAPE_NOT_SHELL";
1613         }
1614       }
1615     }
1616   }
1617
1618   if (aRes.IsEmpty())
1619     SetErrorCode(OK);
1620
1621   return aRes;
1622 }
1623
1624 //=============================================================================
1625 /*!
1626  *  WhatIs
1627  */
1628 //=============================================================================
1629 TCollection_AsciiString GEOMImpl_IMeasureOperations::WhatIs (Handle(GEOM_Object) theShape)
1630 {
1631   SetErrorCode(KO);
1632
1633   TCollection_AsciiString Astr;
1634
1635   if (theShape.IsNull()) return Astr;
1636
1637   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1638   if (aRefShape.IsNull()) return Astr;
1639
1640   TopoDS_Shape aShape = aRefShape->GetValue();
1641   if (aShape.IsNull()) {
1642     SetErrorCode("The Objects has NULL Shape");
1643     return Astr;
1644   }
1645
1646   //Compute the parameters
1647   if (aShape.ShapeType() == TopAbs_EDGE) {
1648     if (BRep_Tool::Degenerated(TopoDS::Edge(aShape))) {
1649       Astr = Astr + " It is a degenerated edge \n";
1650     }
1651   }
1652
1653   Astr = Astr + " Number of sub-shapes : \n";
1654
1655   try {
1656     OCC_CATCH_SIGNALS;
1657     int iType, nbTypes [TopAbs_SHAPE];
1658     for (iType = 0; iType < TopAbs_SHAPE; ++iType)
1659       nbTypes[iType] = 0;
1660     nbTypes[aShape.ShapeType()]++;
1661
1662     TopTools_MapOfShape aMapOfShape;
1663     aMapOfShape.Add(aShape);
1664     TopTools_ListOfShape aListOfShape;
1665     aListOfShape.Append(aShape);
1666
1667     TopTools_ListIteratorOfListOfShape itL (aListOfShape);
1668     for (; itL.More(); itL.Next()) {
1669       TopoDS_Iterator it (itL.Value());
1670       for (; it.More(); it.Next()) {
1671         TopoDS_Shape s = it.Value();
1672         if (aMapOfShape.Add(s)) {
1673           aListOfShape.Append(s);
1674           nbTypes[s.ShapeType()]++;
1675         }
1676       }
1677     }
1678
1679     Astr = Astr + " VERTEX : " + TCollection_AsciiString(nbTypes[TopAbs_VERTEX]) + "\n";
1680     Astr = Astr + " EDGE : " + TCollection_AsciiString(nbTypes[TopAbs_EDGE]) + "\n";
1681     Astr = Astr + " WIRE : " + TCollection_AsciiString(nbTypes[TopAbs_WIRE]) + "\n";
1682     Astr = Astr + " FACE : " + TCollection_AsciiString(nbTypes[TopAbs_FACE]) + "\n";
1683     Astr = Astr + " SHELL : " + TCollection_AsciiString(nbTypes[TopAbs_SHELL]) + "\n";
1684     Astr = Astr + " SOLID : " + TCollection_AsciiString(nbTypes[TopAbs_SOLID]) + "\n";
1685     Astr = Astr + " COMPSOLID : " + TCollection_AsciiString(nbTypes[TopAbs_COMPSOLID]) + "\n";
1686     Astr = Astr + " COMPOUND : " + TCollection_AsciiString(nbTypes[TopAbs_COMPOUND]) + "\n";
1687     Astr = Astr + " SHAPE : " + TCollection_AsciiString(aMapOfShape.Extent());
1688   }
1689   catch (Standard_Failure) {
1690     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1691     SetErrorCode(aFail->GetMessageString());
1692     return Astr;
1693   }
1694
1695   SetErrorCode(OK);
1696   return Astr;
1697 }
1698
1699 //=============================================================================
1700 /*!
1701  *  AreCoordsInside
1702  */
1703 //=============================================================================
1704 std::vector<bool>
1705 GEOMImpl_IMeasureOperations::AreCoordsInside(Handle(GEOM_Object)        theShape,
1706                                              const std::vector<double>& coords,
1707                                              double                     tolerance)
1708 {
1709   std::vector<bool> isInsideRes;
1710   if (!theShape.IsNull()) {
1711     Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1712     if (!aRefShape.IsNull()) {
1713       TopoDS_Shape aShape = aRefShape->GetValue();
1714       if (!aShape.IsNull())
1715       {
1716         TopTools_IndexedMapOfShape mapShape;
1717         {
1718           TopExp_Explorer anExp;
1719           for ( anExp.Init( aShape, TopAbs_SOLID ); anExp.More(); anExp.Next() )
1720             mapShape.Add( anExp.Current() );
1721           for ( anExp.Init( aShape, TopAbs_FACE, TopAbs_SOLID ); anExp.More(); anExp.Next() )
1722             mapShape.Add( anExp.Current() );
1723           for ( anExp.Init( aShape, TopAbs_EDGE, TopAbs_FACE ); anExp.More(); anExp.Next() )
1724             mapShape.Add( anExp.Current() );
1725           for ( anExp.Init( aShape, TopAbs_VERTEX, TopAbs_EDGE ); anExp.More(); anExp.Next() )
1726             mapShape.Add( anExp.Current() ); //// ?????????
1727         }
1728         size_t nb_points = coords.size()/3, nb_points_inside = 0;
1729         isInsideRes.resize( nb_points, false );
1730
1731         for ( int iS = 1; iS <= mapShape.Extent(); ++iS )
1732         {
1733           if ( nb_points_inside == nb_points )
1734             break;
1735           aShape = mapShape( iS );
1736           switch ( aShape.ShapeType() ) {
1737           case TopAbs_SOLID:
1738           {
1739             BRepClass3d_SolidClassifier SC( TopoDS::Solid( aShape ));
1740             for ( size_t i = 0; i < nb_points; i++)
1741             {
1742               if ( isInsideRes[ i ]) continue;
1743               gp_Pnt aPnt( coords[3*i], coords[3*i+1], coords[3*i+2] );
1744               SC.Perform( aPnt, tolerance );
1745               isInsideRes[ i ] = (( SC.State() == TopAbs_IN ) || ( SC.State() == TopAbs_ON ));
1746               nb_points_inside += isInsideRes[ i ];
1747             }
1748             break;
1749           }
1750           case TopAbs_FACE:
1751           {
1752             Standard_Real u1,u2,v1,v2;
1753             const TopoDS_Face&   face = TopoDS::Face( aShape );
1754             Handle(Geom_Surface) surf = BRep_Tool::Surface( face );
1755             surf->Bounds( u1,u2,v1,v2 );
1756             GeomAPI_ProjectPointOnSurf project;
1757             project.Init(surf, u1,u2, v1,v2, tolerance );
1758             for ( size_t i = 0; i < nb_points; i++)
1759             {
1760               if ( isInsideRes[ i ]) continue;
1761               gp_Pnt aPnt( coords[3*i], coords[3*i+1], coords[3*i+2] );
1762               project.Perform( aPnt );
1763               if ( project.IsDone() &&
1764                    project.NbPoints() > 0 &&
1765                    project.LowerDistance() <= tolerance )
1766               {
1767                 Quantity_Parameter u, v;
1768                 project.LowerDistanceParameters(u, v);
1769                 gp_Pnt2d uv( u, v );
1770                 BRepClass_FaceClassifier FC ( face, uv, tolerance );
1771                 isInsideRes[ i ] = (( FC.State() == TopAbs_IN ) || ( FC.State() == TopAbs_ON ));
1772                 nb_points_inside += isInsideRes[ i ];
1773               }
1774             }
1775             break;
1776           }
1777           case TopAbs_EDGE:
1778           {
1779             Standard_Real f,l;
1780             const TopoDS_Edge&  edge = TopoDS::Edge( aShape );
1781             Handle(Geom_Curve) curve = BRep_Tool::Curve( edge, f, l );
1782             GeomAPI_ProjectPointOnCurve project;
1783             project.Init( curve, f, l );
1784             for ( size_t i = 0; i < nb_points; i++)
1785             {
1786               if ( isInsideRes[ i ]) continue;
1787               gp_Pnt aPnt( coords[3*i], coords[3*i+1], coords[3*i+2] );
1788               project.Perform( aPnt );
1789               isInsideRes[ i ] = ( project.NbPoints() > 0 &&
1790                                    project.LowerDistance() <= tolerance );
1791               nb_points_inside += isInsideRes[ i ];
1792             }
1793             break;
1794           }
1795           case TopAbs_VERTEX:
1796           {
1797             gp_Pnt aVPnt = BRep_Tool::Pnt( TopoDS::Vertex( aShape ));
1798             for ( size_t i = 0; i < nb_points; i++)
1799             {
1800               if ( isInsideRes[ i ]) continue;
1801               gp_Pnt aPnt( coords[3*i], coords[3*i+1], coords[3*i+2] );
1802               isInsideRes[ i ] = ( aPnt.SquareDistance( aVPnt ) <= tolerance * tolerance );
1803               nb_points_inside += isInsideRes[ i ];
1804             }
1805             break;
1806           }
1807           default:;
1808           } // switch ( aShape.ShapeType() )
1809         }
1810       }
1811     }
1812   }
1813   return isInsideRes;
1814 }
1815
1816 //=============================================================================
1817 /*!
1818  *  GetMinDistance
1819  */
1820 //=============================================================================
1821 Standard_Real
1822 GEOMImpl_IMeasureOperations::GetMinDistance (Handle(GEOM_Object) theShape1,
1823                                              Handle(GEOM_Object) theShape2,
1824                                              Standard_Real& X1,
1825                                              Standard_Real& Y1,
1826                                              Standard_Real& Z1,
1827                                              Standard_Real& X2,
1828                                              Standard_Real& Y2,
1829                                              Standard_Real& Z2)
1830 {
1831   SetErrorCode(KO);
1832   Standard_Real MinDist = 1.e9;
1833
1834   if (theShape1.IsNull() || theShape2.IsNull()) return MinDist;
1835
1836   Handle(GEOM_Function) aRefShape1 = theShape1->GetLastFunction();
1837   Handle(GEOM_Function) aRefShape2 = theShape2->GetLastFunction();
1838   if (aRefShape1.IsNull() || aRefShape2.IsNull()) return MinDist;
1839
1840   TopoDS_Shape aShape1 = aRefShape1->GetValue();
1841   TopoDS_Shape aShape2 = aRefShape2->GetValue();
1842   if (aShape1.IsNull() || aShape2.IsNull()) {
1843     SetErrorCode("One of Objects has NULL Shape");
1844     return MinDist;
1845   }
1846
1847   //Compute the parameters
1848   try {
1849     OCC_CATCH_SIGNALS;
1850
1851     gp_Pnt aPnt1, aPnt2;
1852
1853     MinDist = GEOMUtils::GetMinDistance(aShape1, aShape2, aPnt1, aPnt2);
1854
1855     if (MinDist >= 0.0) {
1856       aPnt1.Coord(X1, Y1, Z1);
1857       aPnt2.Coord(X2, Y2, Z2);
1858     } else {
1859       return MinDist;
1860     }
1861   }
1862   catch (Standard_Failure) {
1863     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1864     SetErrorCode(aFail->GetMessageString());
1865     return MinDist;
1866   }
1867
1868   SetErrorCode(OK);
1869   return MinDist;
1870 }
1871
1872 //=======================================================================
1873 /*!
1874  *  Get coordinates of closest points of two shapes
1875  */
1876 //=======================================================================
1877 Standard_Integer GEOMImpl_IMeasureOperations::ClosestPoints (Handle(GEOM_Object) theShape1,
1878                                                              Handle(GEOM_Object) theShape2,
1879                                                              Handle(TColStd_HSequenceOfReal)& theDoubles)
1880 {
1881   SetErrorCode(KO);
1882   Standard_Integer nbSolutions = 0;
1883
1884   if (theShape1.IsNull() || theShape2.IsNull()) return nbSolutions;
1885
1886   Handle(GEOM_Function) aRefShape1 = theShape1->GetLastFunction();
1887   Handle(GEOM_Function) aRefShape2 = theShape2->GetLastFunction();
1888   if (aRefShape1.IsNull() || aRefShape2.IsNull()) return nbSolutions;
1889
1890   TopoDS_Shape aShape1 = aRefShape1->GetValue();
1891   TopoDS_Shape aShape2 = aRefShape2->GetValue();
1892   if (aShape1.IsNull() || aShape2.IsNull()) {
1893     SetErrorCode("One of Objects has NULL Shape");
1894     return nbSolutions;
1895   }
1896
1897   // Compute the extremities
1898   try {
1899     OCC_CATCH_SIGNALS;
1900
1901     // skl 30.06.2008
1902     // additional workaround for bugs 19899, 19908 and 19910 from Mantis
1903     gp_Pnt P1, P2;
1904     double dist = GEOMUtils::GetMinDistanceSingular(aShape1, aShape2, P1, P2);
1905     if (dist > -1.0) {
1906       nbSolutions = 1;
1907
1908       theDoubles->Append(P1.X());
1909       theDoubles->Append(P1.Y());
1910       theDoubles->Append(P1.Z());
1911       theDoubles->Append(P2.X());
1912       theDoubles->Append(P2.Y());
1913       theDoubles->Append(P2.Z());
1914
1915       SetErrorCode(OK);
1916       return nbSolutions;
1917     }
1918
1919     BRepExtrema_DistShapeShape dst (aShape1, aShape2);
1920     if (dst.IsDone()) {
1921       nbSolutions = dst.NbSolution();
1922       if (theDoubles.IsNull()) theDoubles = new TColStd_HSequenceOfReal;
1923
1924       gp_Pnt P1, P2;
1925       for (int i = 1; i <= nbSolutions; i++) {
1926         P1 = dst.PointOnShape1(i);
1927         P2 = dst.PointOnShape2(i);
1928
1929         theDoubles->Append(P1.X());
1930         theDoubles->Append(P1.Y());
1931         theDoubles->Append(P1.Z());
1932         theDoubles->Append(P2.X());
1933         theDoubles->Append(P2.Y());
1934         theDoubles->Append(P2.Z());
1935       }
1936     }
1937   }
1938   catch (Standard_Failure) {
1939     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1940     SetErrorCode(aFail->GetMessageString());
1941     return nbSolutions;
1942   }
1943
1944   SetErrorCode(OK);
1945   return nbSolutions;
1946 }
1947
1948 //=======================================================================
1949 /*!
1950  *  Get coordinates of point
1951  */
1952 //=======================================================================
1953 void GEOMImpl_IMeasureOperations::PointCoordinates (Handle(GEOM_Object) theShape,
1954                         Standard_Real& theX, Standard_Real& theY, Standard_Real& theZ)
1955 {
1956   SetErrorCode(KO);
1957
1958   if (theShape.IsNull())
1959     return;
1960
1961   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1962   if (aRefShape.IsNull())
1963     return;
1964
1965   TopoDS_Shape aShape = aRefShape->GetValue();
1966   if (aShape.IsNull() || aShape.ShapeType() != TopAbs_VERTEX)
1967   {
1968     SetErrorCode( "Shape must be a vertex" );
1969     return;
1970   }
1971
1972   try {
1973     OCC_CATCH_SIGNALS;
1974     gp_Pnt aPnt = BRep_Tool::Pnt( TopoDS::Vertex( aShape ) );
1975     theX = aPnt.X();
1976     theY = aPnt.Y();
1977     theZ = aPnt.Z();
1978
1979     SetErrorCode(OK);
1980   }
1981   catch (Standard_Failure)
1982   {
1983     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1984     SetErrorCode( aFail->GetMessageString() );
1985   }
1986 }
1987
1988 //=======================================================================
1989 /*!
1990  *  Compute angle (in degrees) between two lines
1991  */
1992 //=======================================================================
1993 Standard_Real GEOMImpl_IMeasureOperations::GetAngle (Handle(GEOM_Object) theLine1,
1994                                                      Handle(GEOM_Object) theLine2)
1995 {
1996   if (theLine1->GetType() == GEOM_VECTOR &&
1997       theLine2->GetType() == GEOM_VECTOR)
1998     return GetAngleBtwVectors(theLine1, theLine2);
1999
2000   SetErrorCode(KO);
2001
2002   Standard_Real anAngle = -1.0;
2003
2004   if (theLine1.IsNull() || theLine2.IsNull())
2005     return anAngle;
2006
2007   Handle(GEOM_Function) aRefLine1 = theLine1->GetLastFunction();
2008   Handle(GEOM_Function) aRefLine2 = theLine2->GetLastFunction();
2009   if (aRefLine1.IsNull() || aRefLine2.IsNull())
2010     return anAngle;
2011
2012   TopoDS_Shape aLine1 = aRefLine1->GetValue();
2013   TopoDS_Shape aLine2 = aRefLine2->GetValue();
2014   if (aLine1.IsNull() || aLine2.IsNull() ||
2015       aLine1.ShapeType() != TopAbs_EDGE ||
2016       aLine2.ShapeType() != TopAbs_EDGE)
2017   {
2018     SetErrorCode("Two edges must be given");
2019     return anAngle;
2020   }
2021
2022   try {
2023     OCC_CATCH_SIGNALS;
2024     TopoDS_Edge E1 = TopoDS::Edge(aLine1);
2025     TopoDS_Edge E2 = TopoDS::Edge(aLine2);
2026
2027     double fp,lp;
2028     Handle(Geom_Curve) C1 = BRep_Tool::Curve(E1,fp,lp);
2029     Handle(Geom_Curve) C2 = BRep_Tool::Curve(E2,fp,lp);
2030
2031     if ( C1.IsNull() || C2.IsNull() ||
2032         !C1->IsKind(STANDARD_TYPE(Geom_Line)) ||
2033         !C2->IsKind(STANDARD_TYPE(Geom_Line)))
2034     {
2035       SetErrorCode("The edges must be linear");
2036       return anAngle;
2037     }
2038
2039     Handle(Geom_Line) L1 = Handle(Geom_Line)::DownCast(C1);
2040     Handle(Geom_Line) L2 = Handle(Geom_Line)::DownCast(C2);
2041
2042     gp_Lin aLin1 = L1->Lin();
2043     gp_Lin aLin2 = L2->Lin();
2044
2045     anAngle = aLin1.Angle(aLin2);
2046     anAngle *= 180. / M_PI; // convert radians into degrees
2047
2048     if (anAngle > 90.0) {
2049       anAngle = 180.0 - anAngle;
2050     }
2051
2052     SetErrorCode(OK);
2053   }
2054   catch (Standard_Failure)
2055   {
2056     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2057     SetErrorCode(aFail->GetMessageString());
2058   }
2059
2060   return anAngle;
2061 }
2062
2063 //=======================================================================
2064 /*!
2065  *  Compute angle (in degrees) between two vectors
2066  */
2067 //=======================================================================
2068 Standard_Real GEOMImpl_IMeasureOperations::GetAngleBtwVectors (Handle(GEOM_Object) theVec1,
2069                                                                Handle(GEOM_Object) theVec2)
2070 {
2071   SetErrorCode(KO);
2072
2073   Standard_Real anAngle = -1.0;
2074
2075   if (theVec1.IsNull() || theVec2.IsNull())
2076     return anAngle;
2077
2078   if (theVec1->GetType() != GEOM_VECTOR || theVec2->GetType() != GEOM_VECTOR) {
2079     SetErrorCode("Two vectors must be given");
2080     return anAngle;
2081   }
2082
2083   Handle(GEOM_Function) aRefVec1 = theVec1->GetLastFunction();
2084   Handle(GEOM_Function) aRefVec2 = theVec2->GetLastFunction();
2085   if (aRefVec1.IsNull() || aRefVec2.IsNull())
2086     return anAngle;
2087
2088   TopoDS_Shape aVec1 = aRefVec1->GetValue();
2089   TopoDS_Shape aVec2 = aRefVec2->GetValue();
2090   if (aVec1.IsNull() || aVec2.IsNull() ||
2091       aVec1.ShapeType() != TopAbs_EDGE ||
2092       aVec2.ShapeType() != TopAbs_EDGE)
2093   {
2094     SetErrorCode("Two edges must be given");
2095     return anAngle;
2096   }
2097
2098   try {
2099     OCC_CATCH_SIGNALS;
2100     TopoDS_Edge aE1 = TopoDS::Edge(aVec1);
2101     TopoDS_Edge aE2 = TopoDS::Edge(aVec2);
2102
2103     TopoDS_Vertex aP11, aP12, aP21, aP22;
2104     TopExp::Vertices(aE1, aP11, aP12, Standard_True);
2105     TopExp::Vertices(aE2, aP21, aP22, Standard_True);
2106     if (aP11.IsNull() || aP12.IsNull() || aP21.IsNull() || aP22.IsNull()) {
2107       SetErrorCode("Bad edge given");
2108       return anAngle;
2109     }
2110
2111     gp_Vec aV1 (BRep_Tool::Pnt(aP11), BRep_Tool::Pnt(aP12));
2112     gp_Vec aV2 (BRep_Tool::Pnt(aP21), BRep_Tool::Pnt(aP22)) ;
2113
2114     anAngle = aV1.Angle(aV2);
2115     anAngle *= 180. / M_PI; // convert radians into degrees
2116
2117     SetErrorCode(OK);
2118   }
2119   catch (Standard_Failure)
2120   {
2121     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2122     SetErrorCode(aFail->GetMessageString());
2123   }
2124
2125   return anAngle;
2126 }
2127
2128
2129 //=============================================================================
2130 /*!
2131  *  CurveCurvatureByParam
2132  */
2133 //=============================================================================
2134 Standard_Real GEOMImpl_IMeasureOperations::CurveCurvatureByParam
2135                         (Handle(GEOM_Object) theCurve, Standard_Real& theParam)
2136 {
2137   SetErrorCode(KO);
2138   Standard_Real aRes = -1.0;
2139
2140   if(theCurve.IsNull()) return aRes;
2141
2142   Handle(GEOM_Function) aRefShape = theCurve->GetLastFunction();
2143   if(aRefShape.IsNull()) return aRes;
2144
2145   TopoDS_Shape aShape = aRefShape->GetValue();
2146   if(aShape.IsNull()) {
2147     SetErrorCode("One of Objects has NULL Shape");
2148     return aRes;
2149   }
2150
2151   Standard_Real aFP, aLP, aP;
2152   Handle(Geom_Curve) aCurve = BRep_Tool::Curve(TopoDS::Edge(aShape), aFP, aLP);
2153   aP = aFP + (aLP - aFP) * theParam;
2154
2155   if(aCurve.IsNull()) return aRes;
2156
2157   //Compute curvature
2158   try {
2159     OCC_CATCH_SIGNALS;
2160     GeomLProp_CLProps Prop = GeomLProp_CLProps
2161       (aCurve, aP, 2, Precision::Confusion());
2162     aRes = fabs(Prop.Curvature());
2163     SetErrorCode(OK);
2164   }
2165   catch (Standard_Failure) {
2166     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2167     SetErrorCode(aFail->GetMessageString());
2168     return aRes;
2169   }
2170
2171   if( aRes > Precision::Confusion() )
2172     aRes = 1/aRes;
2173   else
2174     aRes = RealLast();
2175
2176   return aRes;
2177 }
2178
2179
2180 //=============================================================================
2181 /*!
2182  *  CurveCurvatureByPoint
2183  */
2184 //=============================================================================
2185 Standard_Real GEOMImpl_IMeasureOperations::CurveCurvatureByPoint
2186                    (Handle(GEOM_Object) theCurve, Handle(GEOM_Object) thePoint)
2187 {
2188   SetErrorCode(KO);
2189   Standard_Real aRes = -1.0;
2190
2191   if( theCurve.IsNull() || thePoint.IsNull() ) return aRes;
2192
2193   Handle(GEOM_Function) aRefCurve = theCurve->GetLastFunction();
2194   Handle(GEOM_Function) aRefPoint = thePoint->GetLastFunction();
2195   if( aRefCurve.IsNull() || aRefPoint.IsNull() ) return aRes;
2196
2197   TopoDS_Edge anEdge = TopoDS::Edge(aRefCurve->GetValue());
2198   TopoDS_Vertex aPnt = TopoDS::Vertex(aRefPoint->GetValue());
2199   if( anEdge.IsNull() || aPnt.IsNull() ) {
2200     SetErrorCode("One of Objects has NULL Shape");
2201     return aRes;
2202   }
2203
2204   Standard_Real aFP, aLP;
2205   Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, aFP, aLP);
2206   if(aCurve.IsNull()) return aRes;
2207   gp_Pnt aPoint = BRep_Tool::Pnt(aPnt);
2208
2209   //Compute curvature
2210   try {
2211     OCC_CATCH_SIGNALS;
2212     GeomAPI_ProjectPointOnCurve PPCurve(aPoint, aCurve, aFP, aLP);
2213     if(PPCurve.NbPoints()>0) {
2214       GeomLProp_CLProps Prop = GeomLProp_CLProps
2215         (aCurve, PPCurve.LowerDistanceParameter(), 2, Precision::Confusion());
2216       aRes = fabs(Prop.Curvature());
2217       SetErrorCode(OK);
2218     }
2219   }
2220   catch (Standard_Failure) {
2221     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2222     SetErrorCode(aFail->GetMessageString());
2223     return aRes;
2224   }
2225
2226   if( aRes > Precision::Confusion() )
2227     aRes = 1/aRes;
2228   else
2229     aRes = RealLast();
2230
2231   return aRes;
2232 }
2233
2234
2235 //=============================================================================
2236 /*!
2237  *  getSurfaceCurvatures
2238  */
2239 //=============================================================================
2240 Standard_Real GEOMImpl_IMeasureOperations::getSurfaceCurvatures
2241                                           (const Handle(Geom_Surface)& aSurf,
2242                                            Standard_Real theUParam,
2243                                            Standard_Real theVParam,
2244                                            Standard_Boolean theNeedMaxCurv)
2245 {
2246   SetErrorCode(KO);
2247   Standard_Real aRes = 1.0;
2248
2249   if (aSurf.IsNull()) return aRes;
2250
2251   try {
2252     OCC_CATCH_SIGNALS;
2253     GeomLProp_SLProps Prop = GeomLProp_SLProps
2254       (aSurf, theUParam, theVParam, 2, Precision::Confusion());
2255     if(Prop.IsCurvatureDefined()) {
2256       if(Prop.IsUmbilic()) {
2257         //cout<<"is umbilic"<<endl;
2258         aRes = fabs(Prop.MeanCurvature());
2259       }
2260       else {
2261         //cout<<"is not umbilic"<<endl;
2262         double c1 = fabs(Prop.MaxCurvature());
2263         double c2 = fabs(Prop.MinCurvature());
2264         if(theNeedMaxCurv)
2265           aRes = Max(c1,c2);
2266         else
2267           aRes = Min(c1,c2);
2268       }
2269       SetErrorCode(OK);
2270     }
2271   }
2272   catch (Standard_Failure) {
2273     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2274     SetErrorCode(aFail->GetMessageString());
2275     return aRes;
2276   }
2277
2278   if( fabs(aRes) > Precision::Confusion() )
2279     aRes = 1/aRes;
2280   else
2281     aRes = RealLast();
2282
2283   return aRes;
2284 }
2285
2286
2287 //=============================================================================
2288 /*!
2289  *  MaxSurfaceCurvatureByParam
2290  */
2291 //=============================================================================
2292 Standard_Real GEOMImpl_IMeasureOperations::MaxSurfaceCurvatureByParam
2293                                                   (Handle(GEOM_Object) theSurf,
2294                                                    Standard_Real& theUParam,
2295                                                    Standard_Real& theVParam)
2296 {
2297   SetErrorCode(KO);
2298   Standard_Real aRes = -1.0;
2299
2300   if (theSurf.IsNull()) return aRes;
2301
2302   Handle(GEOM_Function) aRefShape = theSurf->GetLastFunction();
2303   if(aRefShape.IsNull()) return aRes;
2304
2305   TopoDS_Shape aShape = aRefShape->GetValue();
2306   if(aShape.IsNull()) {
2307     SetErrorCode("One of Objects has NULL Shape");
2308     return aRes;
2309   }
2310
2311   TopoDS_Face F = TopoDS::Face(aShape);
2312   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(F);
2313
2314   //Compute the parameters
2315   Standard_Real U1,U2,V1,V2;
2316   ShapeAnalysis::GetFaceUVBounds(F,U1,U2,V1,V2);
2317   Standard_Real U = U1 + (U2-U1)*theUParam;
2318   Standard_Real V = V1 + (V2-V1)*theVParam;
2319
2320   return getSurfaceCurvatures(aSurf, U, V, true);
2321 }
2322
2323
2324 //=============================================================================
2325 /*!
2326  *  MaxSurfaceCurvatureByPoint
2327  */
2328 //=============================================================================
2329 Standard_Real GEOMImpl_IMeasureOperations::MaxSurfaceCurvatureByPoint
2330                     (Handle(GEOM_Object) theSurf, Handle(GEOM_Object) thePoint)
2331 {
2332   SetErrorCode(KO);
2333   Standard_Real aRes = -1.0;
2334
2335   if( theSurf.IsNull() || thePoint.IsNull() ) return aRes;
2336
2337   Handle(GEOM_Function) aRefShape = theSurf->GetLastFunction();
2338   Handle(GEOM_Function) aRefPoint = thePoint->GetLastFunction();
2339   if( aRefShape.IsNull() || aRefPoint.IsNull() ) return aRes;
2340
2341   TopoDS_Face aFace = TopoDS::Face(aRefShape->GetValue());
2342   TopoDS_Vertex aPnt = TopoDS::Vertex(aRefPoint->GetValue());
2343   if( aFace.IsNull() || aPnt.IsNull() ) {
2344     SetErrorCode("One of Objects has NULL Shape");
2345     return 0;
2346   }
2347
2348   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(aFace);
2349   if(aSurf.IsNull()) return aRes;
2350   gp_Pnt aPoint = BRep_Tool::Pnt(aPnt);
2351
2352   //Compute the parameters
2353   ShapeAnalysis_Surface sas(aSurf);
2354   gp_Pnt2d UV = sas.ValueOfUV(aPoint,Precision::Confusion());
2355
2356   return getSurfaceCurvatures(aSurf, UV.X(), UV.Y(), true);
2357 }
2358
2359
2360 //=============================================================================
2361 /*!
2362  *  MinSurfaceCurvatureByParam
2363  */
2364 //=============================================================================
2365 Standard_Real GEOMImpl_IMeasureOperations::MinSurfaceCurvatureByParam
2366                                                   (Handle(GEOM_Object) theSurf,
2367                                                    Standard_Real& theUParam,
2368                                                    Standard_Real& theVParam)
2369 {
2370   SetErrorCode(KO);
2371   Standard_Real aRes = -1.0;
2372
2373   if (theSurf.IsNull()) return aRes;
2374
2375   Handle(GEOM_Function) aRefShape = theSurf->GetLastFunction();
2376   if(aRefShape.IsNull()) return aRes;
2377
2378   TopoDS_Shape aShape = aRefShape->GetValue();
2379   if(aShape.IsNull()) {
2380     SetErrorCode("One of Objects has NULL Shape");
2381     return aRes;
2382   }
2383
2384   TopoDS_Face F = TopoDS::Face(aShape);
2385   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(F);
2386
2387   //Compute the parameters
2388   Standard_Real U1,U2,V1,V2;
2389   ShapeAnalysis::GetFaceUVBounds(F,U1,U2,V1,V2);
2390   Standard_Real U = U1 + (U2-U1)*theUParam;
2391   Standard_Real V = V1 + (V2-V1)*theVParam;
2392
2393   return getSurfaceCurvatures(aSurf, U, V, false);
2394 }
2395
2396
2397 //=============================================================================
2398 /*!
2399  *  MinSurfaceCurvatureByPoint
2400  */
2401 //=============================================================================
2402 Standard_Real GEOMImpl_IMeasureOperations::MinSurfaceCurvatureByPoint
2403                     (Handle(GEOM_Object) theSurf, Handle(GEOM_Object) thePoint)
2404 {
2405   SetErrorCode(KO);
2406   Standard_Real aRes = -1.0;
2407
2408   if( theSurf.IsNull() || thePoint.IsNull() ) return aRes;
2409
2410   Handle(GEOM_Function) aRefShape = theSurf->GetLastFunction();
2411   Handle(GEOM_Function) aRefPoint = thePoint->GetLastFunction();
2412   if( aRefShape.IsNull() || aRefPoint.IsNull() ) return aRes;
2413
2414   TopoDS_Face aFace = TopoDS::Face(aRefShape->GetValue());
2415   TopoDS_Vertex aPnt = TopoDS::Vertex(aRefPoint->GetValue());
2416   if( aFace.IsNull() || aPnt.IsNull() ) {
2417     SetErrorCode("One of Objects has NULL Shape");
2418     return 0;
2419   }
2420
2421   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(aFace);
2422   if(aSurf.IsNull()) return aRes;
2423   gp_Pnt aPoint = BRep_Tool::Pnt(aPnt);
2424
2425   //Compute the parameters
2426   ShapeAnalysis_Surface sas(aSurf);
2427   gp_Pnt2d UV = sas.ValueOfUV(aPoint,Precision::Confusion());
2428
2429   return getSurfaceCurvatures(aSurf, UV.X(), UV.Y(), false);
2430 }
2431
2432 //=======================================================================
2433 //function : FillErrorsSub
2434 //purpose  : Fill the errors list of subshapes on shape.
2435 //=======================================================================
2436 void GEOMImpl_IMeasureOperations::FillErrorsSub
2437            (const BRepCheck_Analyzer                   &theAna,
2438             const TopoDS_Shape                         &theShape,
2439             const TopAbs_ShapeEnum                     theSubType,
2440                   TopTools_DataMapOfIntegerListOfShape &theMapErrors) const
2441 {
2442   TopExp_Explorer anExp(theShape, theSubType);
2443   TopTools_MapOfShape aMapSubShapes;
2444
2445   for (; anExp.More(); anExp.Next()) {
2446     const TopoDS_Shape &aSubShape = anExp.Current();
2447
2448     if (aMapSubShapes.Add(aSubShape)) {
2449       const Handle(BRepCheck_Result) &aRes = theAna.Result(aSubShape);
2450
2451       for (aRes->InitContextIterator();
2452            aRes->MoreShapeInContext();
2453            aRes->NextShapeInContext()) {
2454         if (aRes->ContextualShape().IsSame(theShape)) {
2455           BRepCheck_ListIteratorOfListOfStatus itl(aRes->StatusOnShape());
2456
2457           if (itl.Value() != BRepCheck_NoError) {
2458             // Add all errors for theShape and its sub-shape.
2459             for (;itl.More(); itl.Next()) {
2460               const Standard_Integer aStat = (Standard_Integer)itl.Value();
2461
2462               if (!theMapErrors.IsBound(aStat)) {
2463                 TopTools_ListOfShape anEmpty;
2464
2465                 theMapErrors.Bind(aStat, anEmpty);
2466               }
2467
2468               TopTools_ListOfShape &theShapes = theMapErrors.ChangeFind(aStat);
2469
2470               theShapes.Append(aSubShape);
2471               theShapes.Append(theShape);
2472             }
2473           }
2474         }
2475
2476         break;
2477       }
2478     }
2479   }
2480 }
2481
2482 //=======================================================================
2483 //function : FillErrors
2484 //purpose  : Fill the errors list.
2485 //=======================================================================
2486 void GEOMImpl_IMeasureOperations::FillErrors
2487              (const BRepCheck_Analyzer                   &theAna,
2488               const TopoDS_Shape                         &theShape,
2489                     TopTools_DataMapOfIntegerListOfShape &theMapErrors,
2490                     TopTools_MapOfShape                  &theMapShapes) const
2491 {
2492   if (theMapShapes.Add(theShape)) {
2493     // Fill errors of child shapes.
2494     for (TopoDS_Iterator iter(theShape); iter.More(); iter.Next()) {
2495       FillErrors(theAna, iter.Value(), theMapErrors, theMapShapes);
2496     }
2497
2498     // Fill errors of theShape.
2499     const Handle(BRepCheck_Result) &aRes = theAna.Result(theShape);
2500
2501     if (!aRes.IsNull()) {
2502       BRepCheck_ListIteratorOfListOfStatus itl(aRes->Status());
2503
2504       if (itl.Value() != BRepCheck_NoError) {
2505         // Add all errors for theShape.
2506         for (;itl.More(); itl.Next()) {
2507           const Standard_Integer aStat = (Standard_Integer)itl.Value();
2508
2509           if (!theMapErrors.IsBound(aStat)) {
2510             TopTools_ListOfShape anEmpty;
2511
2512             theMapErrors.Bind(aStat, anEmpty);
2513           }
2514
2515           theMapErrors.ChangeFind(aStat).Append(theShape);
2516         }
2517       }
2518     }
2519
2520     // Add errors of subshapes on theShape.
2521     const TopAbs_ShapeEnum aType = theShape.ShapeType();
2522
2523     switch (aType) {
2524     case TopAbs_EDGE:
2525       FillErrorsSub(theAna, theShape, TopAbs_VERTEX, theMapErrors);
2526       break;
2527     case TopAbs_FACE:
2528       FillErrorsSub(theAna, theShape, TopAbs_WIRE, theMapErrors);
2529       FillErrorsSub(theAna, theShape, TopAbs_EDGE, theMapErrors);
2530       FillErrorsSub(theAna, theShape, TopAbs_VERTEX, theMapErrors);
2531       break;
2532     case TopAbs_SOLID:
2533       FillErrorsSub(theAna, theShape, TopAbs_SHELL, theMapErrors);
2534       break;
2535     default:
2536       break;
2537     }
2538   }
2539 }
2540
2541 //=======================================================================
2542 //function : FillErrors
2543 //purpose  : Fill the errors list.
2544 //=======================================================================
2545 void GEOMImpl_IMeasureOperations::FillErrors
2546                   (const BRepCheck_Analyzer    &theAna,
2547                    const TopoDS_Shape          &theShape,
2548                          std::list<ShapeError> &theErrors) const
2549 {
2550   // Fill the errors map.
2551   TopTools_DataMapOfIntegerListOfShape aMapErrors;
2552   TopTools_MapOfShape                  aMapShapes;
2553
2554   FillErrors(theAna, theShape, aMapErrors, aMapShapes);
2555
2556   // Map sub-shapes and their indices
2557   TopTools_IndexedMapOfShape anIndices;
2558
2559   TopExp::MapShapes(theShape, anIndices);
2560
2561   TopTools_DataMapIteratorOfDataMapOfIntegerListOfShape aMapIter(aMapErrors);
2562
2563   for (; aMapIter.More(); aMapIter.Next()) {
2564     ShapeError anError;
2565
2566     anError.error = (BRepCheck_Status)aMapIter.Key();
2567
2568     TopTools_ListIteratorOfListOfShape aListIter(aMapIter.Value());
2569     TopTools_MapOfShape                aMapUnique;
2570
2571     for (; aListIter.More(); aListIter.Next()) {
2572       const TopoDS_Shape &aShape = aListIter.Value();
2573
2574       if (aMapUnique.Add(aShape)) {
2575         const Standard_Integer anIndex = anIndices.FindIndex(aShape);
2576
2577         anError.incriminated.push_back(anIndex);
2578       }
2579     }
2580
2581     if (!anError.incriminated.empty()) {
2582       theErrors.push_back(anError);
2583     }
2584   }
2585 }