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 > USER_TYPE ) {
 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], nbFlatType [TopAbs_SHAPE];
1658     for (iType = 0; iType < TopAbs_SHAPE; ++iType) {
1659       nbTypes[iType] = 0;
1660       nbFlatType[iType] = 0;
1661     }
1662     nbTypes[aShape.ShapeType()]++;
1663
1664     TopTools_MapOfShape aMapOfShape;
1665     aMapOfShape.Add(aShape);
1666     TopTools_ListOfShape aListOfShape;
1667     aListOfShape.Append(aShape);
1668
1669     TopTools_ListIteratorOfListOfShape itL (aListOfShape);
1670     for (; itL.More(); itL.Next()) {
1671       TopoDS_Shape sp = itL.Value();
1672       TopoDS_Iterator it (sp);
1673       for (; it.More(); it.Next()) {
1674         TopoDS_Shape s = it.Value();
1675         if (aMapOfShape.Add(s)) {
1676           aListOfShape.Append(s);
1677           nbTypes[s.ShapeType()]++;
1678           if ((sp.ShapeType() == TopAbs_COMPOUND) || (sp.ShapeType() == TopAbs_COMPSOLID)) {
1679             nbFlatType[s.ShapeType()]++;
1680           }
1681         }
1682       }
1683     }
1684
1685     Astr = Astr + " VERTEX : " + TCollection_AsciiString(nbTypes[TopAbs_VERTEX]) + "\n";
1686     Astr = Astr + " EDGE : " + TCollection_AsciiString(nbTypes[TopAbs_EDGE]) + "\n";
1687     Astr = Astr + " WIRE : " + TCollection_AsciiString(nbTypes[TopAbs_WIRE]) + "\n";
1688     Astr = Astr + " FACE : " + TCollection_AsciiString(nbTypes[TopAbs_FACE]) + "\n";
1689     Astr = Astr + " SHELL : " + TCollection_AsciiString(nbTypes[TopAbs_SHELL]) + "\n";
1690     Astr = Astr + " SOLID : " + TCollection_AsciiString(nbTypes[TopAbs_SOLID]) + "\n";
1691     Astr = Astr + " COMPSOLID : " + TCollection_AsciiString(nbTypes[TopAbs_COMPSOLID]) + "\n";
1692     Astr = Astr + " COMPOUND : " + TCollection_AsciiString(nbTypes[TopAbs_COMPOUND]) + "\n";
1693     Astr = Astr + " SHAPE : " + TCollection_AsciiString(aMapOfShape.Extent()) + "\n";
1694
1695     if ((aShape.ShapeType() == TopAbs_COMPOUND) || (aShape.ShapeType() == TopAbs_COMPSOLID)){
1696       Astr = Astr + " --------------------- \n Flat content : \n";
1697       if (nbFlatType[TopAbs_VERTEX] > 0)
1698         Astr = Astr + " VERTEX : " + TCollection_AsciiString(nbFlatType[TopAbs_VERTEX]) + "\n";
1699       if (nbFlatType[TopAbs_EDGE] > 0)
1700         Astr = Astr + " EDGE : " + TCollection_AsciiString(nbFlatType[TopAbs_EDGE]) + "\n";
1701       if (nbFlatType[TopAbs_WIRE] > 0)
1702         Astr = Astr + " WIRE : " + TCollection_AsciiString(nbFlatType[TopAbs_WIRE]) + "\n";
1703       if (nbFlatType[TopAbs_FACE] > 0)
1704         Astr = Astr + " FACE : " + TCollection_AsciiString(nbFlatType[TopAbs_FACE]) + "\n";
1705       if (nbFlatType[TopAbs_SHELL] > 0)
1706         Astr = Astr + " SHELL : " + TCollection_AsciiString(nbFlatType[TopAbs_SHELL]) + "\n";
1707       if (nbFlatType[TopAbs_SOLID] > 0)
1708         Astr = Astr + " SOLID : " + TCollection_AsciiString(nbFlatType[TopAbs_SOLID]) + "\n";
1709     }
1710   }
1711   catch (Standard_Failure) {
1712     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1713     SetErrorCode(aFail->GetMessageString());
1714     return Astr;
1715   }
1716
1717   SetErrorCode(OK);
1718   return Astr;
1719 }
1720
1721 //=============================================================================
1722 /*!
1723  *  AreCoordsInside
1724  */
1725 //=============================================================================
1726 std::vector<bool>
1727 GEOMImpl_IMeasureOperations::AreCoordsInside(Handle(GEOM_Object)        theShape,
1728                                              const std::vector<double>& coords,
1729                                              double                     tolerance)
1730 {
1731   std::vector<bool> isInsideRes;
1732   if (!theShape.IsNull()) {
1733     Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1734     if (!aRefShape.IsNull()) {
1735       TopoDS_Shape aShape = aRefShape->GetValue();
1736       if (!aShape.IsNull())
1737       {
1738         TopTools_IndexedMapOfShape mapShape;
1739         {
1740           TopExp_Explorer anExp;
1741           for ( anExp.Init( aShape, TopAbs_SOLID ); anExp.More(); anExp.Next() )
1742             mapShape.Add( anExp.Current() );
1743           for ( anExp.Init( aShape, TopAbs_FACE, TopAbs_SOLID ); anExp.More(); anExp.Next() )
1744             mapShape.Add( anExp.Current() );
1745           for ( anExp.Init( aShape, TopAbs_EDGE, TopAbs_FACE ); anExp.More(); anExp.Next() )
1746             mapShape.Add( anExp.Current() );
1747           for ( anExp.Init( aShape, TopAbs_VERTEX, TopAbs_EDGE ); anExp.More(); anExp.Next() )
1748             mapShape.Add( anExp.Current() ); //// ?????????
1749         }
1750         size_t nb_points = coords.size()/3, nb_points_inside = 0;
1751         isInsideRes.resize( nb_points, false );
1752
1753         for ( int iS = 1; iS <= mapShape.Extent(); ++iS )
1754         {
1755           if ( nb_points_inside == nb_points )
1756             break;
1757           aShape = mapShape( iS );
1758           switch ( aShape.ShapeType() ) {
1759           case TopAbs_SOLID:
1760           {
1761             BRepClass3d_SolidClassifier SC( TopoDS::Solid( aShape ));
1762             for ( size_t i = 0; i < nb_points; i++)
1763             {
1764               if ( isInsideRes[ i ]) continue;
1765               gp_Pnt aPnt( coords[3*i], coords[3*i+1], coords[3*i+2] );
1766               SC.Perform( aPnt, tolerance );
1767               isInsideRes[ i ] = (( SC.State() == TopAbs_IN ) || ( SC.State() == TopAbs_ON ));
1768               nb_points_inside += isInsideRes[ i ];
1769             }
1770             break;
1771           }
1772           case TopAbs_FACE:
1773           {
1774             Standard_Real u1,u2,v1,v2;
1775             const TopoDS_Face&   face = TopoDS::Face( aShape );
1776             Handle(Geom_Surface) surf = BRep_Tool::Surface( face );
1777             surf->Bounds( u1,u2,v1,v2 );
1778             GeomAPI_ProjectPointOnSurf project;
1779             project.Init(surf, u1,u2, v1,v2, tolerance );
1780             for ( size_t i = 0; i < nb_points; i++)
1781             {
1782               if ( isInsideRes[ i ]) continue;
1783               gp_Pnt aPnt( coords[3*i], coords[3*i+1], coords[3*i+2] );
1784               project.Perform( aPnt );
1785               if ( project.IsDone() &&
1786                    project.NbPoints() > 0 &&
1787                    project.LowerDistance() <= tolerance )
1788               {
1789                 Quantity_Parameter u, v;
1790                 project.LowerDistanceParameters(u, v);
1791                 gp_Pnt2d uv( u, v );
1792                 BRepClass_FaceClassifier FC ( face, uv, tolerance );
1793                 isInsideRes[ i ] = (( FC.State() == TopAbs_IN ) || ( FC.State() == TopAbs_ON ));
1794                 nb_points_inside += isInsideRes[ i ];
1795               }
1796             }
1797             break;
1798           }
1799           case TopAbs_EDGE:
1800           {
1801             Standard_Real f,l;
1802             const TopoDS_Edge&  edge = TopoDS::Edge( aShape );
1803             Handle(Geom_Curve) curve = BRep_Tool::Curve( edge, f, l );
1804             GeomAPI_ProjectPointOnCurve project;
1805             project.Init( curve, f, l );
1806             for ( size_t i = 0; i < nb_points; i++)
1807             {
1808               if ( isInsideRes[ i ]) continue;
1809               gp_Pnt aPnt( coords[3*i], coords[3*i+1], coords[3*i+2] );
1810               project.Perform( aPnt );
1811               isInsideRes[ i ] = ( project.NbPoints() > 0 &&
1812                                    project.LowerDistance() <= tolerance );
1813               nb_points_inside += isInsideRes[ i ];
1814             }
1815             break;
1816           }
1817           case TopAbs_VERTEX:
1818           {
1819             gp_Pnt aVPnt = BRep_Tool::Pnt( TopoDS::Vertex( aShape ));
1820             for ( size_t i = 0; i < nb_points; i++)
1821             {
1822               if ( isInsideRes[ i ]) continue;
1823               gp_Pnt aPnt( coords[3*i], coords[3*i+1], coords[3*i+2] );
1824               isInsideRes[ i ] = ( aPnt.SquareDistance( aVPnt ) <= tolerance * tolerance );
1825               nb_points_inside += isInsideRes[ i ];
1826             }
1827             break;
1828           }
1829           default:;
1830           } // switch ( aShape.ShapeType() )
1831         }
1832       }
1833     }
1834   }
1835   return isInsideRes;
1836 }
1837
1838 //=============================================================================
1839 /*!
1840  *  GetMinDistance
1841  */
1842 //=============================================================================
1843 Standard_Real
1844 GEOMImpl_IMeasureOperations::GetMinDistance (Handle(GEOM_Object) theShape1,
1845                                              Handle(GEOM_Object) theShape2,
1846                                              Standard_Real& X1,
1847                                              Standard_Real& Y1,
1848                                              Standard_Real& Z1,
1849                                              Standard_Real& X2,
1850                                              Standard_Real& Y2,
1851                                              Standard_Real& Z2)
1852 {
1853   SetErrorCode(KO);
1854   Standard_Real MinDist = 1.e9;
1855
1856   if (theShape1.IsNull() || theShape2.IsNull()) return MinDist;
1857
1858   Handle(GEOM_Function) aRefShape1 = theShape1->GetLastFunction();
1859   Handle(GEOM_Function) aRefShape2 = theShape2->GetLastFunction();
1860   if (aRefShape1.IsNull() || aRefShape2.IsNull()) return MinDist;
1861
1862   TopoDS_Shape aShape1 = aRefShape1->GetValue();
1863   TopoDS_Shape aShape2 = aRefShape2->GetValue();
1864   if (aShape1.IsNull() || aShape2.IsNull()) {
1865     SetErrorCode("One of Objects has NULL Shape");
1866     return MinDist;
1867   }
1868
1869   //Compute the parameters
1870   try {
1871     OCC_CATCH_SIGNALS;
1872
1873     gp_Pnt aPnt1, aPnt2;
1874
1875     MinDist = GEOMUtils::GetMinDistance(aShape1, aShape2, aPnt1, aPnt2);
1876
1877     if (MinDist >= 0.0) {
1878       aPnt1.Coord(X1, Y1, Z1);
1879       aPnt2.Coord(X2, Y2, Z2);
1880     } else {
1881       return MinDist;
1882     }
1883   }
1884   catch (Standard_Failure) {
1885     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1886     SetErrorCode(aFail->GetMessageString());
1887     return MinDist;
1888   }
1889
1890   SetErrorCode(OK);
1891   return MinDist;
1892 }
1893
1894 //=======================================================================
1895 /*!
1896  *  Get coordinates of closest points of two shapes
1897  */
1898 //=======================================================================
1899 Standard_Integer GEOMImpl_IMeasureOperations::ClosestPoints (Handle(GEOM_Object) theShape1,
1900                                                              Handle(GEOM_Object) theShape2,
1901                                                              Handle(TColStd_HSequenceOfReal)& theDoubles)
1902 {
1903   SetErrorCode(KO);
1904   Standard_Integer nbSolutions = 0;
1905
1906   if (theShape1.IsNull() || theShape2.IsNull()) return nbSolutions;
1907
1908   Handle(GEOM_Function) aRefShape1 = theShape1->GetLastFunction();
1909   Handle(GEOM_Function) aRefShape2 = theShape2->GetLastFunction();
1910   if (aRefShape1.IsNull() || aRefShape2.IsNull()) return nbSolutions;
1911
1912   TopoDS_Shape aShape1 = aRefShape1->GetValue();
1913   TopoDS_Shape aShape2 = aRefShape2->GetValue();
1914   if (aShape1.IsNull() || aShape2.IsNull()) {
1915     SetErrorCode("One of Objects has NULL Shape");
1916     return nbSolutions;
1917   }
1918
1919   // Compute the extremities
1920   try {
1921     OCC_CATCH_SIGNALS;
1922
1923     // skl 30.06.2008
1924     // additional workaround for bugs 19899, 19908 and 19910 from Mantis
1925     gp_Pnt P1, P2;
1926     double dist = GEOMUtils::GetMinDistanceSingular(aShape1, aShape2, P1, P2);
1927     if (dist > -1.0) {
1928       nbSolutions = 1;
1929
1930       theDoubles->Append(P1.X());
1931       theDoubles->Append(P1.Y());
1932       theDoubles->Append(P1.Z());
1933       theDoubles->Append(P2.X());
1934       theDoubles->Append(P2.Y());
1935       theDoubles->Append(P2.Z());
1936
1937       SetErrorCode(OK);
1938       return nbSolutions;
1939     }
1940
1941     BRepExtrema_DistShapeShape dst (aShape1, aShape2);
1942     if (dst.IsDone()) {
1943       nbSolutions = dst.NbSolution();
1944       if (theDoubles.IsNull()) theDoubles = new TColStd_HSequenceOfReal;
1945
1946       gp_Pnt P1, P2;
1947       for (int i = 1; i <= nbSolutions; i++) {
1948         P1 = dst.PointOnShape1(i);
1949         P2 = dst.PointOnShape2(i);
1950
1951         theDoubles->Append(P1.X());
1952         theDoubles->Append(P1.Y());
1953         theDoubles->Append(P1.Z());
1954         theDoubles->Append(P2.X());
1955         theDoubles->Append(P2.Y());
1956         theDoubles->Append(P2.Z());
1957       }
1958     }
1959   }
1960   catch (Standard_Failure) {
1961     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1962     SetErrorCode(aFail->GetMessageString());
1963     return nbSolutions;
1964   }
1965
1966   SetErrorCode(OK);
1967   return nbSolutions;
1968 }
1969
1970 //=======================================================================
1971 /*!
1972  *  Get coordinates of point
1973  */
1974 //=======================================================================
1975 void GEOMImpl_IMeasureOperations::PointCoordinates (Handle(GEOM_Object) theShape,
1976                         Standard_Real& theX, Standard_Real& theY, Standard_Real& theZ)
1977 {
1978   SetErrorCode(KO);
1979
1980   if (theShape.IsNull())
1981     return;
1982
1983   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
1984   if (aRefShape.IsNull())
1985     return;
1986
1987   TopoDS_Shape aShape = aRefShape->GetValue();
1988   if (aShape.IsNull() || aShape.ShapeType() != TopAbs_VERTEX)
1989   {
1990     SetErrorCode( "Shape must be a vertex" );
1991     return;
1992   }
1993
1994   try {
1995     OCC_CATCH_SIGNALS;
1996     gp_Pnt aPnt = BRep_Tool::Pnt( TopoDS::Vertex( aShape ) );
1997     theX = aPnt.X();
1998     theY = aPnt.Y();
1999     theZ = aPnt.Z();
2000
2001     SetErrorCode(OK);
2002   }
2003   catch (Standard_Failure)
2004   {
2005     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2006     SetErrorCode( aFail->GetMessageString() );
2007   }
2008 }
2009
2010 //=======================================================================
2011 /*!
2012  *  Compute angle (in degrees) between two lines
2013  */
2014 //=======================================================================
2015 Standard_Real GEOMImpl_IMeasureOperations::GetAngle (Handle(GEOM_Object) theLine1,
2016                                                      Handle(GEOM_Object) theLine2)
2017 {
2018   if (theLine1->GetType() == GEOM_VECTOR &&
2019       theLine2->GetType() == GEOM_VECTOR)
2020     return GetAngleBtwVectors(theLine1, theLine2);
2021
2022   SetErrorCode(KO);
2023
2024   Standard_Real anAngle = -1.0;
2025
2026   if (theLine1.IsNull() || theLine2.IsNull())
2027     return anAngle;
2028
2029   Handle(GEOM_Function) aRefLine1 = theLine1->GetLastFunction();
2030   Handle(GEOM_Function) aRefLine2 = theLine2->GetLastFunction();
2031   if (aRefLine1.IsNull() || aRefLine2.IsNull())
2032     return anAngle;
2033
2034   TopoDS_Shape aLine1 = aRefLine1->GetValue();
2035   TopoDS_Shape aLine2 = aRefLine2->GetValue();
2036   if (aLine1.IsNull() || aLine2.IsNull() ||
2037       aLine1.ShapeType() != TopAbs_EDGE ||
2038       aLine2.ShapeType() != TopAbs_EDGE)
2039   {
2040     SetErrorCode("Two edges must be given");
2041     return anAngle;
2042   }
2043
2044   try {
2045     OCC_CATCH_SIGNALS;
2046     TopoDS_Edge E1 = TopoDS::Edge(aLine1);
2047     TopoDS_Edge E2 = TopoDS::Edge(aLine2);
2048
2049     double fp,lp;
2050     Handle(Geom_Curve) C1 = BRep_Tool::Curve(E1,fp,lp);
2051     Handle(Geom_Curve) C2 = BRep_Tool::Curve(E2,fp,lp);
2052
2053     if ( C1.IsNull() || C2.IsNull() ||
2054         !C1->IsKind(STANDARD_TYPE(Geom_Line)) ||
2055         !C2->IsKind(STANDARD_TYPE(Geom_Line)))
2056     {
2057       SetErrorCode("The edges must be linear");
2058       return anAngle;
2059     }
2060
2061     Handle(Geom_Line) L1 = Handle(Geom_Line)::DownCast(C1);
2062     Handle(Geom_Line) L2 = Handle(Geom_Line)::DownCast(C2);
2063
2064     gp_Lin aLin1 = L1->Lin();
2065     gp_Lin aLin2 = L2->Lin();
2066
2067     anAngle = aLin1.Angle(aLin2);
2068     anAngle *= 180. / M_PI; // convert radians into degrees
2069
2070     if (anAngle > 90.0) {
2071       anAngle = 180.0 - anAngle;
2072     }
2073
2074     SetErrorCode(OK);
2075   }
2076   catch (Standard_Failure)
2077   {
2078     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2079     SetErrorCode(aFail->GetMessageString());
2080   }
2081
2082   return anAngle;
2083 }
2084
2085 //=======================================================================
2086 /*!
2087  *  Compute angle (in degrees) between two vectors
2088  */
2089 //=======================================================================
2090 Standard_Real GEOMImpl_IMeasureOperations::GetAngleBtwVectors (Handle(GEOM_Object) theVec1,
2091                                                                Handle(GEOM_Object) theVec2)
2092 {
2093   SetErrorCode(KO);
2094
2095   Standard_Real anAngle = -1.0;
2096
2097   if (theVec1.IsNull() || theVec2.IsNull())
2098     return anAngle;
2099
2100   if (theVec1->GetType() != GEOM_VECTOR || theVec2->GetType() != GEOM_VECTOR) {
2101     SetErrorCode("Two vectors must be given");
2102     return anAngle;
2103   }
2104
2105   Handle(GEOM_Function) aRefVec1 = theVec1->GetLastFunction();
2106   Handle(GEOM_Function) aRefVec2 = theVec2->GetLastFunction();
2107   if (aRefVec1.IsNull() || aRefVec2.IsNull())
2108     return anAngle;
2109
2110   TopoDS_Shape aVec1 = aRefVec1->GetValue();
2111   TopoDS_Shape aVec2 = aRefVec2->GetValue();
2112   if (aVec1.IsNull() || aVec2.IsNull() ||
2113       aVec1.ShapeType() != TopAbs_EDGE ||
2114       aVec2.ShapeType() != TopAbs_EDGE)
2115   {
2116     SetErrorCode("Two edges must be given");
2117     return anAngle;
2118   }
2119
2120   try {
2121     OCC_CATCH_SIGNALS;
2122     TopoDS_Edge aE1 = TopoDS::Edge(aVec1);
2123     TopoDS_Edge aE2 = TopoDS::Edge(aVec2);
2124
2125     TopoDS_Vertex aP11, aP12, aP21, aP22;
2126     TopExp::Vertices(aE1, aP11, aP12, Standard_True);
2127     TopExp::Vertices(aE2, aP21, aP22, Standard_True);
2128     if (aP11.IsNull() || aP12.IsNull() || aP21.IsNull() || aP22.IsNull()) {
2129       SetErrorCode("Bad edge given");
2130       return anAngle;
2131     }
2132
2133     gp_Vec aV1 (BRep_Tool::Pnt(aP11), BRep_Tool::Pnt(aP12));
2134     gp_Vec aV2 (BRep_Tool::Pnt(aP21), BRep_Tool::Pnt(aP22)) ;
2135
2136     anAngle = aV1.Angle(aV2);
2137     anAngle *= 180. / M_PI; // convert radians into degrees
2138
2139     SetErrorCode(OK);
2140   }
2141   catch (Standard_Failure)
2142   {
2143     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2144     SetErrorCode(aFail->GetMessageString());
2145   }
2146
2147   return anAngle;
2148 }
2149
2150
2151 //=============================================================================
2152 /*!
2153  *  CurveCurvatureByParam
2154  */
2155 //=============================================================================
2156 Standard_Real GEOMImpl_IMeasureOperations::CurveCurvatureByParam
2157                         (Handle(GEOM_Object) theCurve, Standard_Real& theParam)
2158 {
2159   SetErrorCode(KO);
2160   Standard_Real aRes = -1.0;
2161
2162   if(theCurve.IsNull()) return aRes;
2163
2164   Handle(GEOM_Function) aRefShape = theCurve->GetLastFunction();
2165   if(aRefShape.IsNull()) return aRes;
2166
2167   TopoDS_Shape aShape = aRefShape->GetValue();
2168   if(aShape.IsNull()) {
2169     SetErrorCode("One of Objects has NULL Shape");
2170     return aRes;
2171   }
2172
2173   Standard_Real aFP, aLP, aP;
2174   Handle(Geom_Curve) aCurve = BRep_Tool::Curve(TopoDS::Edge(aShape), aFP, aLP);
2175   aP = aFP + (aLP - aFP) * theParam;
2176
2177   if(aCurve.IsNull()) return aRes;
2178
2179   //Compute curvature
2180   try {
2181     OCC_CATCH_SIGNALS;
2182     GeomLProp_CLProps Prop = GeomLProp_CLProps
2183       (aCurve, aP, 2, Precision::Confusion());
2184     aRes = fabs(Prop.Curvature());
2185     SetErrorCode(OK);
2186   }
2187   catch (Standard_Failure) {
2188     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2189     SetErrorCode(aFail->GetMessageString());
2190     return aRes;
2191   }
2192
2193   if( aRes > Precision::Confusion() )
2194     aRes = 1/aRes;
2195   else
2196     aRes = RealLast();
2197
2198   return aRes;
2199 }
2200
2201
2202 //=============================================================================
2203 /*!
2204  *  CurveCurvatureByPoint
2205  */
2206 //=============================================================================
2207 Standard_Real GEOMImpl_IMeasureOperations::CurveCurvatureByPoint
2208                    (Handle(GEOM_Object) theCurve, Handle(GEOM_Object) thePoint)
2209 {
2210   SetErrorCode(KO);
2211   Standard_Real aRes = -1.0;
2212
2213   if( theCurve.IsNull() || thePoint.IsNull() ) return aRes;
2214
2215   Handle(GEOM_Function) aRefCurve = theCurve->GetLastFunction();
2216   Handle(GEOM_Function) aRefPoint = thePoint->GetLastFunction();
2217   if( aRefCurve.IsNull() || aRefPoint.IsNull() ) return aRes;
2218
2219   TopoDS_Edge anEdge = TopoDS::Edge(aRefCurve->GetValue());
2220   TopoDS_Vertex aPnt = TopoDS::Vertex(aRefPoint->GetValue());
2221   if( anEdge.IsNull() || aPnt.IsNull() ) {
2222     SetErrorCode("One of Objects has NULL Shape");
2223     return aRes;
2224   }
2225
2226   Standard_Real aFP, aLP;
2227   Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, aFP, aLP);
2228   if(aCurve.IsNull()) return aRes;
2229   gp_Pnt aPoint = BRep_Tool::Pnt(aPnt);
2230
2231   //Compute curvature
2232   try {
2233     OCC_CATCH_SIGNALS;
2234     GeomAPI_ProjectPointOnCurve PPCurve(aPoint, aCurve, aFP, aLP);
2235     if(PPCurve.NbPoints()>0) {
2236       GeomLProp_CLProps Prop = GeomLProp_CLProps
2237         (aCurve, PPCurve.LowerDistanceParameter(), 2, Precision::Confusion());
2238       aRes = fabs(Prop.Curvature());
2239       SetErrorCode(OK);
2240     }
2241   }
2242   catch (Standard_Failure) {
2243     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2244     SetErrorCode(aFail->GetMessageString());
2245     return aRes;
2246   }
2247
2248   if( aRes > Precision::Confusion() )
2249     aRes = 1/aRes;
2250   else
2251     aRes = RealLast();
2252
2253   return aRes;
2254 }
2255
2256
2257 //=============================================================================
2258 /*!
2259  *  getSurfaceCurvatures
2260  */
2261 //=============================================================================
2262 Standard_Real GEOMImpl_IMeasureOperations::getSurfaceCurvatures
2263                                           (const Handle(Geom_Surface)& aSurf,
2264                                            Standard_Real theUParam,
2265                                            Standard_Real theVParam,
2266                                            Standard_Boolean theNeedMaxCurv)
2267 {
2268   SetErrorCode(KO);
2269   Standard_Real aRes = 1.0;
2270
2271   if (aSurf.IsNull()) return aRes;
2272
2273   try {
2274     OCC_CATCH_SIGNALS;
2275     GeomLProp_SLProps Prop = GeomLProp_SLProps
2276       (aSurf, theUParam, theVParam, 2, Precision::Confusion());
2277     if(Prop.IsCurvatureDefined()) {
2278       if(Prop.IsUmbilic()) {
2279         //cout<<"is umbilic"<<endl;
2280         aRes = fabs(Prop.MeanCurvature());
2281       }
2282       else {
2283         //cout<<"is not umbilic"<<endl;
2284         double c1 = fabs(Prop.MaxCurvature());
2285         double c2 = fabs(Prop.MinCurvature());
2286         if(theNeedMaxCurv)
2287           aRes = Max(c1,c2);
2288         else
2289           aRes = Min(c1,c2);
2290       }
2291       SetErrorCode(OK);
2292     }
2293   }
2294   catch (Standard_Failure) {
2295     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2296     SetErrorCode(aFail->GetMessageString());
2297     return aRes;
2298   }
2299
2300   if( fabs(aRes) > Precision::Confusion() )
2301     aRes = 1/aRes;
2302   else
2303     aRes = RealLast();
2304
2305   return aRes;
2306 }
2307
2308
2309 //=============================================================================
2310 /*!
2311  *  MaxSurfaceCurvatureByParam
2312  */
2313 //=============================================================================
2314 Standard_Real GEOMImpl_IMeasureOperations::MaxSurfaceCurvatureByParam
2315                                                   (Handle(GEOM_Object) theSurf,
2316                                                    Standard_Real& theUParam,
2317                                                    Standard_Real& theVParam)
2318 {
2319   SetErrorCode(KO);
2320   Standard_Real aRes = -1.0;
2321
2322   if (theSurf.IsNull()) return aRes;
2323
2324   Handle(GEOM_Function) aRefShape = theSurf->GetLastFunction();
2325   if(aRefShape.IsNull()) return aRes;
2326
2327   TopoDS_Shape aShape = aRefShape->GetValue();
2328   if(aShape.IsNull()) {
2329     SetErrorCode("One of Objects has NULL Shape");
2330     return aRes;
2331   }
2332
2333   TopoDS_Face F = TopoDS::Face(aShape);
2334   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(F);
2335
2336   //Compute the parameters
2337   Standard_Real U1,U2,V1,V2;
2338   ShapeAnalysis::GetFaceUVBounds(F,U1,U2,V1,V2);
2339   Standard_Real U = U1 + (U2-U1)*theUParam;
2340   Standard_Real V = V1 + (V2-V1)*theVParam;
2341
2342   return getSurfaceCurvatures(aSurf, U, V, true);
2343 }
2344
2345
2346 //=============================================================================
2347 /*!
2348  *  MaxSurfaceCurvatureByPoint
2349  */
2350 //=============================================================================
2351 Standard_Real GEOMImpl_IMeasureOperations::MaxSurfaceCurvatureByPoint
2352                     (Handle(GEOM_Object) theSurf, Handle(GEOM_Object) thePoint)
2353 {
2354   SetErrorCode(KO);
2355   Standard_Real aRes = -1.0;
2356
2357   if( theSurf.IsNull() || thePoint.IsNull() ) return aRes;
2358
2359   Handle(GEOM_Function) aRefShape = theSurf->GetLastFunction();
2360   Handle(GEOM_Function) aRefPoint = thePoint->GetLastFunction();
2361   if( aRefShape.IsNull() || aRefPoint.IsNull() ) return aRes;
2362
2363   TopoDS_Face aFace = TopoDS::Face(aRefShape->GetValue());
2364   TopoDS_Vertex aPnt = TopoDS::Vertex(aRefPoint->GetValue());
2365   if( aFace.IsNull() || aPnt.IsNull() ) {
2366     SetErrorCode("One of Objects has NULL Shape");
2367     return 0;
2368   }
2369
2370   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(aFace);
2371   if(aSurf.IsNull()) return aRes;
2372   gp_Pnt aPoint = BRep_Tool::Pnt(aPnt);
2373
2374   //Compute the parameters
2375   ShapeAnalysis_Surface sas(aSurf);
2376   gp_Pnt2d UV = sas.ValueOfUV(aPoint,Precision::Confusion());
2377
2378   return getSurfaceCurvatures(aSurf, UV.X(), UV.Y(), true);
2379 }
2380
2381
2382 //=============================================================================
2383 /*!
2384  *  MinSurfaceCurvatureByParam
2385  */
2386 //=============================================================================
2387 Standard_Real GEOMImpl_IMeasureOperations::MinSurfaceCurvatureByParam
2388                                                   (Handle(GEOM_Object) theSurf,
2389                                                    Standard_Real& theUParam,
2390                                                    Standard_Real& theVParam)
2391 {
2392   SetErrorCode(KO);
2393   Standard_Real aRes = -1.0;
2394
2395   if (theSurf.IsNull()) return aRes;
2396
2397   Handle(GEOM_Function) aRefShape = theSurf->GetLastFunction();
2398   if(aRefShape.IsNull()) return aRes;
2399
2400   TopoDS_Shape aShape = aRefShape->GetValue();
2401   if(aShape.IsNull()) {
2402     SetErrorCode("One of Objects has NULL Shape");
2403     return aRes;
2404   }
2405
2406   TopoDS_Face F = TopoDS::Face(aShape);
2407   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(F);
2408
2409   //Compute the parameters
2410   Standard_Real U1,U2,V1,V2;
2411   ShapeAnalysis::GetFaceUVBounds(F,U1,U2,V1,V2);
2412   Standard_Real U = U1 + (U2-U1)*theUParam;
2413   Standard_Real V = V1 + (V2-V1)*theVParam;
2414
2415   return getSurfaceCurvatures(aSurf, U, V, false);
2416 }
2417
2418
2419 //=============================================================================
2420 /*!
2421  *  MinSurfaceCurvatureByPoint
2422  */
2423 //=============================================================================
2424 Standard_Real GEOMImpl_IMeasureOperations::MinSurfaceCurvatureByPoint
2425                     (Handle(GEOM_Object) theSurf, Handle(GEOM_Object) thePoint)
2426 {
2427   SetErrorCode(KO);
2428   Standard_Real aRes = -1.0;
2429
2430   if( theSurf.IsNull() || thePoint.IsNull() ) return aRes;
2431
2432   Handle(GEOM_Function) aRefShape = theSurf->GetLastFunction();
2433   Handle(GEOM_Function) aRefPoint = thePoint->GetLastFunction();
2434   if( aRefShape.IsNull() || aRefPoint.IsNull() ) return aRes;
2435
2436   TopoDS_Face aFace = TopoDS::Face(aRefShape->GetValue());
2437   TopoDS_Vertex aPnt = TopoDS::Vertex(aRefPoint->GetValue());
2438   if( aFace.IsNull() || aPnt.IsNull() ) {
2439     SetErrorCode("One of Objects has NULL Shape");
2440     return 0;
2441   }
2442
2443   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(aFace);
2444   if(aSurf.IsNull()) return aRes;
2445   gp_Pnt aPoint = BRep_Tool::Pnt(aPnt);
2446
2447   //Compute the parameters
2448   ShapeAnalysis_Surface sas(aSurf);
2449   gp_Pnt2d UV = sas.ValueOfUV(aPoint,Precision::Confusion());
2450
2451   return getSurfaceCurvatures(aSurf, UV.X(), UV.Y(), false);
2452 }
2453
2454 //=======================================================================
2455 //function : FillErrorsSub
2456 //purpose  : Fill the errors list of subshapes on shape.
2457 //=======================================================================
2458 void GEOMImpl_IMeasureOperations::FillErrorsSub
2459            (const BRepCheck_Analyzer                   &theAna,
2460             const TopoDS_Shape                         &theShape,
2461             const TopAbs_ShapeEnum                     theSubType,
2462                   TopTools_DataMapOfIntegerListOfShape &theMapErrors) const
2463 {
2464   TopExp_Explorer anExp(theShape, theSubType);
2465   TopTools_MapOfShape aMapSubShapes;
2466
2467   for (; anExp.More(); anExp.Next()) {
2468     const TopoDS_Shape &aSubShape = anExp.Current();
2469
2470     if (aMapSubShapes.Add(aSubShape)) {
2471       const Handle(BRepCheck_Result) &aRes = theAna.Result(aSubShape);
2472
2473       for (aRes->InitContextIterator();
2474            aRes->MoreShapeInContext();
2475            aRes->NextShapeInContext()) {
2476         if (aRes->ContextualShape().IsSame(theShape)) {
2477           BRepCheck_ListIteratorOfListOfStatus itl(aRes->StatusOnShape());
2478
2479           if (itl.Value() != BRepCheck_NoError) {
2480             // Add all errors for theShape and its sub-shape.
2481             for (;itl.More(); itl.Next()) {
2482               const Standard_Integer aStat = (Standard_Integer)itl.Value();
2483
2484               if (!theMapErrors.IsBound(aStat)) {
2485                 TopTools_ListOfShape anEmpty;
2486
2487                 theMapErrors.Bind(aStat, anEmpty);
2488               }
2489
2490               TopTools_ListOfShape &theShapes = theMapErrors.ChangeFind(aStat);
2491
2492               theShapes.Append(aSubShape);
2493               theShapes.Append(theShape);
2494             }
2495           }
2496         }
2497
2498         break;
2499       }
2500     }
2501   }
2502 }
2503
2504 //=======================================================================
2505 //function : FillErrors
2506 //purpose  : Fill the errors list.
2507 //=======================================================================
2508 void GEOMImpl_IMeasureOperations::FillErrors
2509              (const BRepCheck_Analyzer                   &theAna,
2510               const TopoDS_Shape                         &theShape,
2511                     TopTools_DataMapOfIntegerListOfShape &theMapErrors,
2512                     TopTools_MapOfShape                  &theMapShapes) const
2513 {
2514   if (theMapShapes.Add(theShape)) {
2515     // Fill errors of child shapes.
2516     for (TopoDS_Iterator iter(theShape); iter.More(); iter.Next()) {
2517       FillErrors(theAna, iter.Value(), theMapErrors, theMapShapes);
2518     }
2519
2520     // Fill errors of theShape.
2521     const Handle(BRepCheck_Result) &aRes = theAna.Result(theShape);
2522
2523     if (!aRes.IsNull()) {
2524       BRepCheck_ListIteratorOfListOfStatus itl(aRes->Status());
2525
2526       if (itl.Value() != BRepCheck_NoError) {
2527         // Add all errors for theShape.
2528         for (;itl.More(); itl.Next()) {
2529           const Standard_Integer aStat = (Standard_Integer)itl.Value();
2530
2531           if (!theMapErrors.IsBound(aStat)) {
2532             TopTools_ListOfShape anEmpty;
2533
2534             theMapErrors.Bind(aStat, anEmpty);
2535           }
2536
2537           theMapErrors.ChangeFind(aStat).Append(theShape);
2538         }
2539       }
2540     }
2541
2542     // Add errors of subshapes on theShape.
2543     const TopAbs_ShapeEnum aType = theShape.ShapeType();
2544
2545     switch (aType) {
2546     case TopAbs_EDGE:
2547       FillErrorsSub(theAna, theShape, TopAbs_VERTEX, theMapErrors);
2548       break;
2549     case TopAbs_FACE:
2550       FillErrorsSub(theAna, theShape, TopAbs_WIRE, theMapErrors);
2551       FillErrorsSub(theAna, theShape, TopAbs_EDGE, theMapErrors);
2552       FillErrorsSub(theAna, theShape, TopAbs_VERTEX, theMapErrors);
2553       break;
2554     case TopAbs_SOLID:
2555       FillErrorsSub(theAna, theShape, TopAbs_SHELL, theMapErrors);
2556       break;
2557     default:
2558       break;
2559     }
2560   }
2561 }
2562
2563 //=======================================================================
2564 //function : FillErrors
2565 //purpose  : Fill the errors list.
2566 //=======================================================================
2567 void GEOMImpl_IMeasureOperations::FillErrors
2568                   (const BRepCheck_Analyzer    &theAna,
2569                    const TopoDS_Shape          &theShape,
2570                          std::list<ShapeError> &theErrors) const
2571 {
2572   // Fill the errors map.
2573   TopTools_DataMapOfIntegerListOfShape aMapErrors;
2574   TopTools_MapOfShape                  aMapShapes;
2575
2576   FillErrors(theAna, theShape, aMapErrors, aMapShapes);
2577
2578   // Map sub-shapes and their indices
2579   TopTools_IndexedMapOfShape anIndices;
2580
2581   TopExp::MapShapes(theShape, anIndices);
2582
2583   TopTools_DataMapIteratorOfDataMapOfIntegerListOfShape aMapIter(aMapErrors);
2584
2585   for (; aMapIter.More(); aMapIter.Next()) {
2586     ShapeError anError;
2587
2588     anError.error = (BRepCheck_Status)aMapIter.Key();
2589
2590     TopTools_ListIteratorOfListOfShape aListIter(aMapIter.Value());
2591     TopTools_MapOfShape                aMapUnique;
2592
2593     for (; aListIter.More(); aListIter.Next()) {
2594       const TopoDS_Shape &aShape = aListIter.Value();
2595
2596       if (aMapUnique.Add(aShape)) {
2597         const Standard_Integer anIndex = anIndices.FindIndex(aShape);
2598
2599         anError.incriminated.push_back(anIndex);
2600       }
2601     }
2602
2603     if (!anError.incriminated.empty()) {
2604       theErrors.push_back(anError);
2605     }
2606   }
2607 }