src/GEOMImpl/GEOMImpl_IMeasureOperations.cxx

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