src/GEOMImpl/GEOMImpl_IMeasureOperations.cxx

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