src/GEOMImpl/GEOMImpl_IBlocksOperations.cxx

   1 using namespace std;
   2
   3 #include "GEOMImpl_IBlocksOperations.hxx"
   4
   5 #include "GEOMImpl_Types.hxx"
   6
   7 #include "GEOMImpl_BlockDriver.hxx"
   8 #include "GEOMImpl_IBlocks.hxx"
   9 #include "GEOMImpl_IBlockTrsf.hxx"
  10 #include "GEOMImpl_CopyDriver.hxx"
  11 #include "GEOMImpl_Block6Explorer.hxx"
  12
  13 #include "GEOM_Function.hxx"
  14
  15 #include "utilities.h"
  16 #include "OpUtil.hxx"
  17 #include "Utils_ExceptHandlers.hxx"
  18
  19 #include <TFunction_DriverTable.hxx>
  20 #include <TFunction_Driver.hxx>
  21 #include <TFunction_Logbook.hxx>
  22 #include <TDF_Tool.hxx>
  23
  24 #include <BRep_Tool.hxx>
  25 #include <BRepTools.hxx>
  26 #include <BRepGProp.hxx>
  27 #include <BRepBndLib.hxx>
  28 #include <BRepAdaptor_Surface.hxx>
  29 #include <BRepClass_FaceClassifier.hxx>
  30 #include <BRepClass3d_SolidClassifier.hxx>
  31 #include <BRepExtrema_DistShapeShape.hxx>
  32
  33 #include <TopAbs.hxx>
  34 #include <TopoDS.hxx>
  35 #include <TopoDS_Edge.hxx>
  36 #include <TopoDS_Vertex.hxx>
  37 #include <TopoDS_Iterator.hxx>
  38 #include <TopExp.hxx>
  39 #include <TopExp_Explorer.hxx>
  40 #include <TopTools_MapOfShape.hxx>
  41 #include <TopTools_Array1OfShape.hxx>
  42 #include <TopTools_IndexedMapOfShape.hxx>
  43 #include <TopTools_ListIteratorOfListOfShape.hxx>
  44 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
  45
  46 #include <Bnd_Box.hxx>
  47 #include <Precision.hxx>
  48 #include <GProp_GProps.hxx>
  49 #include <TColStd_MapOfInteger.hxx>
  50 #include <TColStd_Array1OfReal.hxx>
  51 #include <TColStd_Array1OfInteger.hxx>
  52 #include <TColStd_Array2OfInteger.hxx>
  53
  54 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
  55
  56 //=============================================================================
  57 /*!
  58  *   constructor:
  59  */
  60 //=============================================================================
  61 GEOMImpl_IBlocksOperations::GEOMImpl_IBlocksOperations (GEOM_Engine* theEngine, int theDocID)
  62 : GEOM_IOperations(theEngine, theDocID)
  63 {
  64   MESSAGE("GEOMImpl_IBlocksOperations::GEOMImpl_IBlocksOperations");
  65 }
  66
  67 //=============================================================================
  68 /*!
  69  *  destructor
  70  */
  71 //=============================================================================
  72 GEOMImpl_IBlocksOperations::~GEOMImpl_IBlocksOperations()
  73 {
  74   MESSAGE("GEOMImpl_IBlocksOperations::~GEOMImpl_IBlocksOperations");
  75 }
  76
  77
  78 //=============================================================================
  79 /*!
  80  *  MakeQuad
  81  */
  82 //=============================================================================
  83 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::MakeQuad
  84                      (Handle(GEOM_Object) theEdge1, Handle(GEOM_Object) theEdge2,
  85                       Handle(GEOM_Object) theEdge3, Handle(GEOM_Object) theEdge4)
  86 {
  87   SetErrorCode(KO);
  88
  89   if (theEdge1.IsNull() || theEdge2.IsNull() ||
  90       theEdge3.IsNull() || theEdge4.IsNull()) return NULL;
  91
  92   //Add a new Face object
  93   Handle(GEOM_Object) aFace = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
  94
  95   //Add a new Face function
  96   Handle(GEOM_Function) aFunction =
  97     aFace->AddFunction(GEOMImpl_BlockDriver::GetID(), BLOCK_FACE_FOUR_EDGES);
  98
  99   //Check if the function is set correctly
 100   if (aFunction->GetDriverGUID() != GEOMImpl_BlockDriver::GetID()) return NULL;
 101
 102   GEOMImpl_IBlocks aPI (aFunction);
 103
 104   Handle(GEOM_Function) aRef1 = theEdge1->GetLastFunction();
 105   Handle(GEOM_Function) aRef2 = theEdge2->GetLastFunction();
 106   Handle(GEOM_Function) aRef3 = theEdge3->GetLastFunction();
 107   Handle(GEOM_Function) aRef4 = theEdge4->GetLastFunction();
 108   if (aRef1.IsNull() || aRef2.IsNull() ||
 109       aRef3.IsNull() || aRef4.IsNull()) return NULL;
 110
 111   Handle(TColStd_HSequenceOfTransient) aShapesSeq = new TColStd_HSequenceOfTransient;
 112   aShapesSeq->Append(aRef1);
 113   aShapesSeq->Append(aRef2);
 114   aShapesSeq->Append(aRef3);
 115   aShapesSeq->Append(aRef4);
 116
 117   aPI.SetShapes(aShapesSeq);
 118
 119   //Compute the Face value
 120   try {
 121     if (!GetSolver()->ComputeFunction(aFunction)) {
 122       SetErrorCode("Block driver failed to compute a face");
 123       return NULL;
 124     }
 125   }
 126   catch (Standard_Failure) {
 127     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 128     SetErrorCode(aFail->GetMessageString());
 129     return NULL;
 130   }
 131
 132   //Make a Python command
 133   TCollection_AsciiString anEntry, aDescr;
 134   TDF_Tool::Entry(aFace->GetEntry(), anEntry);
 135   aDescr += anEntry + " = IBlocksOperations.MakeQuad(";
 136   TDF_Tool::Entry(theEdge1->GetEntry(), anEntry);
 137   aDescr += anEntry + ", ";
 138   TDF_Tool::Entry(theEdge2->GetEntry(), anEntry);
 139   aDescr += anEntry + ", ";
 140   TDF_Tool::Entry(theEdge3->GetEntry(), anEntry);
 141   aDescr += anEntry + ", ";
 142   TDF_Tool::Entry(theEdge4->GetEntry(), anEntry);
 143   aDescr += anEntry + ")";
 144
 145   aFunction->SetDescription(aDescr);
 146
 147   SetErrorCode(OK);
 148   return aFace;
 149 }
 150
 151 //=============================================================================
 152 /*!
 153  *  MakeQuad2Edges
 154  */
 155 //=============================================================================
 156 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::MakeQuad2Edges
 157                      (Handle(GEOM_Object) theEdge1, Handle(GEOM_Object) theEdge2)
 158 {
 159   SetErrorCode(KO);
 160
 161   if (theEdge1.IsNull() || theEdge2.IsNull()) return NULL;
 162
 163   //Add a new Face object
 164   Handle(GEOM_Object) aFace = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
 165
 166   //Add a new Face function
 167   Handle(GEOM_Function) aFunction =
 168     aFace->AddFunction(GEOMImpl_BlockDriver::GetID(), BLOCK_FACE_TWO_EDGES);
 169
 170   //Check if the function is set correctly
 171   if (aFunction->GetDriverGUID() != GEOMImpl_BlockDriver::GetID()) return NULL;
 172
 173   GEOMImpl_IBlocks aPI (aFunction);
 174
 175   Handle(GEOM_Function) aRef1 = theEdge1->GetLastFunction();
 176   Handle(GEOM_Function) aRef2 = theEdge2->GetLastFunction();
 177   if (aRef1.IsNull() || aRef2.IsNull()) return NULL;
 178
 179   Handle(TColStd_HSequenceOfTransient) aShapesSeq = new TColStd_HSequenceOfTransient;
 180   aShapesSeq->Append(aRef1);
 181   aShapesSeq->Append(aRef2);
 182
 183   aPI.SetShapes(aShapesSeq);
 184
 185   //Compute the Face value
 186   try {
 187     if (!GetSolver()->ComputeFunction(aFunction)) {
 188       SetErrorCode("Block driver failed to compute a face");
 189       return NULL;
 190     }
 191   }
 192   catch (Standard_Failure) {
 193     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 194     SetErrorCode(aFail->GetMessageString());
 195     return NULL;
 196   }
 197
 198   //Make a Python command
 199   TCollection_AsciiString anEntry, aDescr;
 200   TDF_Tool::Entry(aFace->GetEntry(), anEntry);
 201   aDescr += anEntry + " = IBlocksOperations.MakeQuad2Edges(";
 202   TDF_Tool::Entry(theEdge1->GetEntry(), anEntry);
 203   aDescr += anEntry + ", ";
 204   TDF_Tool::Entry(theEdge2->GetEntry(), anEntry);
 205   aDescr += anEntry + ")";
 206
 207   aFunction->SetDescription(aDescr);
 208
 209   SetErrorCode(OK);
 210   return aFace;
 211 }
 212
 213 //=============================================================================
 214 /*!
 215  *  MakeQuad4Vertices
 216  */
 217 //=============================================================================
 218 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::MakeQuad4Vertices
 219                      (Handle(GEOM_Object) thePnt1, Handle(GEOM_Object) thePnt2,
 220                       Handle(GEOM_Object) thePnt3, Handle(GEOM_Object) thePnt4)
 221 {
 222   SetErrorCode(KO);
 223
 224   if (thePnt1.IsNull() || thePnt2.IsNull() ||
 225       thePnt3.IsNull() || thePnt4.IsNull()) return NULL;
 226
 227   //Add a new Face object
 228   Handle(GEOM_Object) aFace = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
 229
 230   //Add a new Face function
 231   Handle(GEOM_Function) aFunction =
 232     aFace->AddFunction(GEOMImpl_BlockDriver::GetID(), BLOCK_FACE_FOUR_PNT);
 233
 234   //Check if the function is set correctly
 235   if (aFunction->GetDriverGUID() != GEOMImpl_BlockDriver::GetID()) return NULL;
 236
 237   GEOMImpl_IBlocks aPI (aFunction);
 238
 239   Handle(GEOM_Function) aRef1 = thePnt1->GetLastFunction();
 240   Handle(GEOM_Function) aRef2 = thePnt2->GetLastFunction();
 241   Handle(GEOM_Function) aRef3 = thePnt3->GetLastFunction();
 242   Handle(GEOM_Function) aRef4 = thePnt4->GetLastFunction();
 243   if (aRef1.IsNull() || aRef2.IsNull() ||
 244       aRef3.IsNull() || aRef4.IsNull()) return NULL;
 245
 246   Handle(TColStd_HSequenceOfTransient) aShapesSeq = new TColStd_HSequenceOfTransient;
 247   aShapesSeq->Append(aRef1);
 248   aShapesSeq->Append(aRef2);
 249   aShapesSeq->Append(aRef3);
 250   aShapesSeq->Append(aRef4);
 251
 252   aPI.SetShapes(aShapesSeq);
 253
 254   //Compute the Face value
 255   try {
 256     if (!GetSolver()->ComputeFunction(aFunction)) {
 257       SetErrorCode("Block driver failed to compute a face");
 258       return NULL;
 259     }
 260   }
 261   catch (Standard_Failure) {
 262     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 263     SetErrorCode(aFail->GetMessageString());
 264     return NULL;
 265   }
 266
 267   //Make a Python command
 268   TCollection_AsciiString anEntry, aDescr;
 269   TDF_Tool::Entry(aFace->GetEntry(), anEntry);
 270   aDescr += anEntry + " = IBlocksOperations.MakeQuad4Vertices(";
 271   TDF_Tool::Entry(thePnt1->GetEntry(), anEntry);
 272   aDescr += anEntry + ", ";
 273   TDF_Tool::Entry(thePnt2->GetEntry(), anEntry);
 274   aDescr += anEntry + ", ";
 275   TDF_Tool::Entry(thePnt3->GetEntry(), anEntry);
 276   aDescr += anEntry + ", ";
 277   TDF_Tool::Entry(thePnt4->GetEntry(), anEntry);
 278   aDescr += anEntry + ")";
 279
 280   aFunction->SetDescription(aDescr);
 281
 282   SetErrorCode(OK);
 283   return aFace;
 284 }
 285
 286 //=============================================================================
 287 /*!
 288  *  MakeHexa
 289  */
 290 //=============================================================================
 291 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::MakeHexa
 292                      (Handle(GEOM_Object) theFace1, Handle(GEOM_Object) theFace2,
 293                       Handle(GEOM_Object) theFace3, Handle(GEOM_Object) theFace4,
 294                       Handle(GEOM_Object) theFace5, Handle(GEOM_Object) theFace6)
 295 {
 296   SetErrorCode(KO);
 297
 298   if (theFace1.IsNull() || theFace2.IsNull() ||
 299       theFace3.IsNull() || theFace4.IsNull() ||
 300       theFace5.IsNull() || theFace6.IsNull()) return NULL;
 301
 302   //Add a new Solid object
 303   Handle(GEOM_Object) aBlock = GetEngine()->AddObject(GetDocID(), GEOM_BLOCK);
 304
 305   //Add a new Block function
 306   Handle(GEOM_Function) aFunction =
 307     aBlock->AddFunction(GEOMImpl_BlockDriver::GetID(), BLOCK_SIX_FACES);
 308
 309   //Check if the function is set correctly
 310   if (aFunction->GetDriverGUID() != GEOMImpl_BlockDriver::GetID()) return NULL;
 311
 312   GEOMImpl_IBlocks aPI (aFunction);
 313
 314   Handle(GEOM_Function) aRef1 = theFace1->GetLastFunction();
 315   Handle(GEOM_Function) aRef2 = theFace2->GetLastFunction();
 316   Handle(GEOM_Function) aRef3 = theFace3->GetLastFunction();
 317   Handle(GEOM_Function) aRef4 = theFace4->GetLastFunction();
 318   Handle(GEOM_Function) aRef5 = theFace5->GetLastFunction();
 319   Handle(GEOM_Function) aRef6 = theFace6->GetLastFunction();
 320   if (aRef1.IsNull() || aRef2.IsNull() ||
 321       aRef3.IsNull() || aRef4.IsNull() ||
 322       aRef5.IsNull() || aRef6.IsNull()) return NULL;
 323
 324   Handle(TColStd_HSequenceOfTransient) aShapesSeq = new TColStd_HSequenceOfTransient;
 325   aShapesSeq->Append(aRef1);
 326   aShapesSeq->Append(aRef2);
 327   aShapesSeq->Append(aRef3);
 328   aShapesSeq->Append(aRef4);
 329   aShapesSeq->Append(aRef5);
 330   aShapesSeq->Append(aRef6);
 331
 332   aPI.SetShapes(aShapesSeq);
 333
 334   //Compute the Block value
 335   try {
 336     if (!GetSolver()->ComputeFunction(aFunction)) {
 337       SetErrorCode("Block driver failed to compute a block");
 338       return NULL;
 339     }
 340   }
 341   catch (Standard_Failure) {
 342     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 343     SetErrorCode(aFail->GetMessageString());
 344     return NULL;
 345   }
 346
 347   //Make a Python command
 348   TCollection_AsciiString anEntry, aDescr;
 349   TDF_Tool::Entry(aBlock->GetEntry(), anEntry);
 350   aDescr += anEntry + " = IBlocksOperations.MakeHexa(";
 351   TDF_Tool::Entry(theFace1->GetEntry(), anEntry);
 352   aDescr += anEntry + ", ";
 353   TDF_Tool::Entry(theFace2->GetEntry(), anEntry);
 354   aDescr += anEntry + ", ";
 355   TDF_Tool::Entry(theFace3->GetEntry(), anEntry);
 356   aDescr += anEntry + ", ";
 357   TDF_Tool::Entry(theFace4->GetEntry(), anEntry);
 358   aDescr += anEntry + ", ";
 359   TDF_Tool::Entry(theFace5->GetEntry(), anEntry);
 360   aDescr += anEntry + ", ";
 361   TDF_Tool::Entry(theFace6->GetEntry(), anEntry);
 362   aDescr += anEntry + ")";
 363
 364   aFunction->SetDescription(aDescr);
 365
 366   SetErrorCode(OK);
 367   return aBlock;
 368 }
 369
 370 //=============================================================================
 371 /*!
 372  *  MakeHexa2Faces
 373  */
 374 //=============================================================================
 375 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::MakeHexa2Faces
 376                    (Handle(GEOM_Object) theFace1, Handle(GEOM_Object) theFace2)
 377 {
 378   SetErrorCode(KO);
 379
 380   if (theFace1.IsNull() || theFace2.IsNull()) return NULL;
 381
 382   //Add a new Solid object
 383   Handle(GEOM_Object) aBlock = GetEngine()->AddObject(GetDocID(), GEOM_BLOCK);
 384
 385   //Add a new Block function
 386   Handle(GEOM_Function) aFunction =
 387     aBlock->AddFunction(GEOMImpl_BlockDriver::GetID(), BLOCK_TWO_FACES);
 388
 389   //Check if the function is set correctly
 390   if (aFunction->GetDriverGUID() != GEOMImpl_BlockDriver::GetID()) return NULL;
 391
 392   GEOMImpl_IBlocks aPI (aFunction);
 393
 394   Handle(GEOM_Function) aRef1 = theFace1->GetLastFunction();
 395   Handle(GEOM_Function) aRef2 = theFace2->GetLastFunction();
 396   if (aRef1.IsNull() || aRef2.IsNull()) return NULL;
 397
 398   Handle(TColStd_HSequenceOfTransient) aShapesSeq = new TColStd_HSequenceOfTransient;
 399   aShapesSeq->Append(aRef1);
 400   aShapesSeq->Append(aRef2);
 401
 402   aPI.SetShapes(aShapesSeq);
 403
 404   //Compute the Block value
 405   try {
 406     if (!GetSolver()->ComputeFunction(aFunction)) {
 407       SetErrorCode("Block driver failed to compute a block");
 408       return NULL;
 409     }
 410   }
 411   catch (Standard_Failure) {
 412     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 413     SetErrorCode(aFail->GetMessageString());
 414     return NULL;
 415   }
 416
 417   //Make a Python command
 418   TCollection_AsciiString anEntry, aDescr;
 419   TDF_Tool::Entry(aBlock->GetEntry(), anEntry);
 420   aDescr += anEntry + " = IBlocksOperations.MakeHexa2Faces(";
 421   TDF_Tool::Entry(theFace1->GetEntry(), anEntry);
 422   aDescr += anEntry + ", ";
 423   TDF_Tool::Entry(theFace2->GetEntry(), anEntry);
 424   aDescr += anEntry + ")";
 425
 426   aFunction->SetDescription(aDescr);
 427
 428   SetErrorCode(OK);
 429   return aBlock;
 430 }
 431
 432 //=============================================================================
 433 /*!
 434  *  MakeBlockCompound
 435  */
 436 //=============================================================================
 437 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::MakeBlockCompound
 438                                               (Handle(GEOM_Object) theCompound)
 439 {
 440   SetErrorCode(KO);
 441
 442   if (theCompound.IsNull()) return NULL;
 443
 444   //Add a new object
 445   Handle(GEOM_Object) aBlockComp = GetEngine()->AddObject(GetDocID(), GEOM_COMPOUND);
 446
 447   //Add a new BlocksComp function
 448   Handle(GEOM_Function) aFunction =
 449     aBlockComp->AddFunction(GEOMImpl_BlockDriver::GetID(), BLOCK_COMPOUND_GLUE);
 450
 451   //Check if the function is set correctly
 452   if (aFunction->GetDriverGUID() != GEOMImpl_BlockDriver::GetID()) return NULL;
 453
 454   GEOMImpl_IBlocks aPI (aFunction);
 455
 456   Handle(GEOM_Function) aRef1 = theCompound->GetLastFunction();
 457   if (aRef1.IsNull()) return NULL;
 458
 459   Handle(TColStd_HSequenceOfTransient) aShapesSeq = new TColStd_HSequenceOfTransient;
 460   aShapesSeq->Append(aRef1);
 461
 462   aPI.SetShapes(aShapesSeq);
 463
 464   //Compute the Blocks Compound value
 465   try {
 466     if (!GetSolver()->ComputeFunction(aFunction)) {
 467       SetErrorCode("Block driver failed to compute a blocks compound");
 468       return NULL;
 469     }
 470   }
 471   catch (Standard_Failure) {
 472     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 473     SetErrorCode(aFail->GetMessageString());
 474     return NULL;
 475   }
 476
 477   //Make a Python command
 478   TCollection_AsciiString anEntry, aDescr;
 479   TDF_Tool::Entry(aBlockComp->GetEntry(), anEntry);
 480   aDescr += anEntry + " = IBlocksOperations.MakeBlockCompound(";
 481   TDF_Tool::Entry(theCompound->GetEntry(), anEntry);
 482   aDescr += anEntry + ")";
 483
 484   aFunction->SetDescription(aDescr);
 485
 486   SetErrorCode(OK);
 487   return aBlockComp;
 488 }
 489
 490 //=============================================================================
 491 /*!
 492  *  GetEdge
 493  */
 494 //=============================================================================
 495 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetPoint
 496                                                (Handle(GEOM_Object) theShape,
 497                                                 const Standard_Real theX,
 498                                                 const Standard_Real theY,
 499                                                 const Standard_Real theZ,
 500                                                 const Standard_Real theEpsilon)
 501 {
 502   SetErrorCode(KO);
 503
 504   //New Point object
 505   Handle(GEOM_Object) aResult;
 506
 507   // Arguments
 508   if (theShape.IsNull()) return NULL;
 509
 510   TopoDS_Shape aBlockOrComp = theShape->GetValue();
 511   if (aBlockOrComp.IsNull()) {
 512     SetErrorCode("Block or compound is null");
 513     return NULL;
 514   }
 515   if (aBlockOrComp.ShapeType() != TopAbs_SOLID &&
 516       aBlockOrComp.ShapeType() != TopAbs_COMPOUND &&
 517       aBlockOrComp.ShapeType() != TopAbs_COMPSOLID) {
 518     SetErrorCode("Shape is neither a block, nor a compound of blocks");
 519     return NULL;
 520   }
 521
 522   //Compute the Vertex value
 523   gp_Pnt P (theX, theY, theZ);
 524   Standard_Real eps = Max(theEpsilon, Precision::Confusion());
 525
 526   TopoDS_Shape V;
 527   Standard_Integer isFound = 0;
 528   TopTools_MapOfShape mapShape;
 529   TopExp_Explorer exp (aBlockOrComp, TopAbs_VERTEX);
 530
 531   for (; exp.More(); exp.Next()) {
 532     if (mapShape.Add(exp.Current())) {
 533       TopoDS_Vertex aVi = TopoDS::Vertex(exp.Current());
 534       gp_Pnt aPi = BRep_Tool::Pnt(aVi);
 535       if (aPi.Distance(P) < eps) {
 536         V = aVi;
 537         isFound++;
 538       }
 539     }
 540   }
 541
 542   if (isFound == 0) {
 543     SetErrorCode("Vertex has not been found");
 544     return NULL;
 545   } else if (isFound > 1) {
 546     SetErrorCode("Multiple vertices found by the given coordinates and epsilon");
 547     return NULL;
 548   } else {
 549     TopTools_IndexedMapOfShape anIndices;
 550     TopExp::MapShapes(aBlockOrComp, anIndices);
 551     Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
 552     anArray->SetValue(1, anIndices.FindIndex(V));
 553     aResult = GetEngine()->AddSubShape(theShape, anArray);
 554   }
 555
 556   //The GetPoint() doesn't change object so no new function is required.
 557   Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
 558
 559   //Make a Python command
 560   TCollection_AsciiString anEntry, aDescr;
 561   TDF_Tool::Entry(aResult->GetEntry(), anEntry);
 562   aDescr += anEntry + " = IBlocksOperations.GetPoint(";
 563   TDF_Tool::Entry(theShape->GetEntry(), anEntry);
 564   aDescr += anEntry + ", ";
 565   aDescr += TCollection_AsciiString(theX) + ", ";
 566   aDescr += TCollection_AsciiString(theY) + ", ";
 567   aDescr += TCollection_AsciiString(theZ) + ", ";
 568   aDescr += TCollection_AsciiString(theEpsilon) + ")";
 569
 570   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
 571   aNewDescr += aDescr;
 572   aFunction->SetDescription(aNewDescr);
 573
 574   SetErrorCode(OK);
 575   return aResult;
 576 }
 577
 578 //=============================================================================
 579 /*!
 580  *  GetEdge
 581  */
 582 //=============================================================================
 583 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetEdge
 584                                                 (Handle(GEOM_Object) theShape,
 585                                                  Handle(GEOM_Object) thePoint1,
 586                                                  Handle(GEOM_Object) thePoint2)
 587 {
 588   SetErrorCode(KO);
 589
 590   //New Edge object
 591   Handle(GEOM_Object) aResult;
 592
 593   // Arguments
 594   if (theShape.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
 595
 596   TopoDS_Shape aBlockOrComp = theShape->GetValue();
 597   if (aBlockOrComp.IsNull()) {
 598     SetErrorCode("Block or compound is null");
 599     return NULL;
 600   }
 601   if (aBlockOrComp.ShapeType() != TopAbs_SOLID &&
 602       aBlockOrComp.ShapeType() != TopAbs_COMPOUND &&
 603       aBlockOrComp.ShapeType() != TopAbs_COMPSOLID) {
 604     SetErrorCode("Shape is neither a block, nor a compound of blocks");
 605     return NULL;
 606   }
 607
 608   TopoDS_Shape anArg1 = thePoint1->GetValue();
 609   TopoDS_Shape anArg2 = thePoint2->GetValue();
 610   if (anArg1.IsNull() || anArg2.IsNull()) {
 611     SetErrorCode("Null shape is given as argument");
 612     return NULL;
 613   }
 614   if (anArg1.ShapeType() != TopAbs_VERTEX ||
 615       anArg2.ShapeType() != TopAbs_VERTEX) {
 616     SetErrorCode("Element for edge identification is not a vertex");
 617     return NULL;
 618   }
 619
 620   //Compute the Edge value
 621   try {
 622     TopTools_IndexedDataMapOfShapeListOfShape MVE;
 623     GEOMImpl_Block6Explorer::MapShapesAndAncestors
 624       (aBlockOrComp, TopAbs_VERTEX, TopAbs_EDGE, MVE);
 625
 626     TopoDS_Shape V1,V2;
 627     Standard_Integer ish, ext = MVE.Extent();
 628
 629     if (MVE.Contains(anArg1)) {
 630       V1 = anArg1;
 631     } else {
 632       for (ish = 1; ish <= ext; ish++) {
 633         TopoDS_Shape aShi = MVE.FindKey(ish);
 634         if (BRepTools::Compare(TopoDS::Vertex(anArg1), TopoDS::Vertex(aShi))) {
 635           V1 = aShi;
 636           break;
 637         }
 638       }
 639     }
 640
 641     if (MVE.Contains(anArg2)) {
 642       V2 = anArg2;
 643     } else {
 644       for (ish = 1; ish <= ext; ish++) {
 645         TopoDS_Shape aShi = MVE.FindKey(ish);
 646         if (BRepTools::Compare(TopoDS::Vertex(anArg2), TopoDS::Vertex(aShi))) {
 647           V2 = aShi;
 648           break;
 649         }
 650       }
 651     }
 652
 653     if (V1.IsNull() || V2.IsNull()) {
 654       SetErrorCode("The given vertex does not belong to the shape");
 655       return NULL;
 656     }
 657
 658     TopoDS_Shape anEdge;
 659     Standard_Integer isFound =
 660       GEOMImpl_Block6Explorer::FindEdge(anEdge, V1, V2, MVE, Standard_True);
 661     if (isFound == 0) {
 662       SetErrorCode("The given vertices do not belong to one edge of the given shape");
 663       return NULL;
 664     } else if (isFound > 1) {
 665       SetErrorCode("Multiple edges found by the given vertices of the shape");
 666       return NULL;
 667     } else {
 668       TopTools_IndexedMapOfShape anIndices;
 669       TopExp::MapShapes(aBlockOrComp, anIndices);
 670       Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
 671       anArray->SetValue(1, anIndices.FindIndex(anEdge));
 672       aResult = GetEngine()->AddSubShape(theShape, anArray);
 673     }
 674   } catch (Standard_Failure) {
 675     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 676     SetErrorCode(aFail->GetMessageString());
 677     return NULL;
 678   }
 679
 680   //The GetEdge() doesn't change object so no new function is required.
 681   Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
 682
 683   //Make a Python command
 684   TCollection_AsciiString anEntry, aDescr;
 685   TDF_Tool::Entry(aResult->GetEntry(), anEntry);
 686   aDescr += anEntry + " = IBlocksOperations.GetEdge(";
 687   TDF_Tool::Entry(theShape->GetEntry(), anEntry);
 688   aDescr += anEntry + ", ";
 689   TDF_Tool::Entry(thePoint1->GetEntry(), anEntry);
 690   aDescr += anEntry + ", ";
 691   TDF_Tool::Entry(thePoint2->GetEntry(), anEntry);
 692   aDescr += anEntry + ")";
 693
 694   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
 695   aNewDescr += aDescr;
 696   aFunction->SetDescription(aNewDescr);
 697
 698   SetErrorCode(OK);
 699   return aResult;
 700 }
 701
 702 //=============================================================================
 703 /*!
 704  *  GetEdgeNearPoint
 705  */
 706 //=============================================================================
 707 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetEdgeNearPoint
 708                                                 (Handle(GEOM_Object) theShape,
 709                                                  Handle(GEOM_Object) thePoint)
 710 {
 711   SetErrorCode(KO);
 712
 713   //New object
 714   Handle(GEOM_Object) aResult;
 715
 716   // Arguments
 717   if (theShape.IsNull() || thePoint.IsNull()) return NULL;
 718
 719   TopoDS_Shape aBlockOrComp = theShape->GetValue();
 720   if (aBlockOrComp.IsNull()) {
 721     SetErrorCode("Block or compound is null");
 722     return NULL;
 723   }
 724   if (aBlockOrComp.ShapeType() != TopAbs_SOLID &&
 725       aBlockOrComp.ShapeType() != TopAbs_COMPOUND &&
 726       aBlockOrComp.ShapeType() != TopAbs_COMPSOLID) {
 727     SetErrorCode("Shape is neither a block, nor a compound of blocks");
 728     return NULL;
 729   }
 730
 731   TopoDS_Shape anArg = thePoint->GetValue();
 732   if (anArg.IsNull()) {
 733     SetErrorCode("Null shape is given as argument");
 734     return NULL;
 735   }
 736   if (anArg.ShapeType() != TopAbs_VERTEX) {
 737     SetErrorCode("Element for edge identification is not a vertex");
 738     return NULL;
 739   }
 740
 741   //Compute the Edge value
 742   try {
 743     TopoDS_Shape aShape;
 744
 745     TopoDS_Vertex aVert = TopoDS::Vertex(anArg);
 746
 747     // 1. Explode blocks on edges
 748     TopTools_MapOfShape mapShape;
 749     Standard_Integer nbEdges = 0;
 750     TopExp_Explorer exp (aBlockOrComp, TopAbs_EDGE);
 751     for (; exp.More(); exp.Next()) {
 752       if (mapShape.Add(exp.Current())) {
 753         nbEdges++;
 754       }
 755     }
 756
 757     mapShape.Clear();
 758     Standard_Integer ind = 1;
 759     TopTools_Array1OfShape anEdges (1, nbEdges);
 760     TColStd_Array1OfReal aDistances (1, nbEdges);
 761     for (exp.Init(aBlockOrComp, TopAbs_EDGE); exp.More(); exp.Next()) {
 762       if (mapShape.Add(exp.Current())) {
 763         TopoDS_Shape anEdge = exp.Current();
 764         anEdges(ind) = anEdge;
 765
 766         // 2. Classify the point relatively each edge
 767         BRepExtrema_DistShapeShape aDistTool (aVert, anEdges(ind));
 768         if (!aDistTool.IsDone()) {
 769           SetErrorCode("Can not find a distance from the given point to one of edges");
 770           return NULL;
 771         }
 772         aDistances(ind) = aDistTool.Value();
 773         ind++;
 774       }
 775     }
 776
 777     // 3. Define edge, having minimum distance to the point
 778     Standard_Real nearest = RealLast(), nbFound = 0;
 779     Standard_Real prec = Precision::Confusion();
 780     for (ind = 1; ind <= nbEdges; ind++) {
 781       if (Abs(aDistances(ind) - nearest) < prec) {
 782         nbFound++;
 783       } else if (aDistances(ind) < nearest) {
 784         nearest = aDistances(ind);
 785         aShape = anEdges(ind);
 786         nbFound = 1;
 787       } else {
 788       }
 789     }
 790     if (nbFound > 1) {
 791       SetErrorCode("Multiple edges near the given point are found");
 792       return NULL;
 793     } else if (nbFound == 0) {
 794       SetErrorCode("There are no edges near the given point");
 795       return NULL;
 796     } else {
 797       TopTools_IndexedMapOfShape anIndices;
 798       TopExp::MapShapes(aBlockOrComp, anIndices);
 799       Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
 800       anArray->SetValue(1, anIndices.FindIndex(aShape));
 801       aResult = GetEngine()->AddSubShape(theShape, anArray);
 802     }
 803   }
 804   catch (Standard_Failure) {
 805     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 806     SetErrorCode(aFail->GetMessageString());
 807     return NULL;
 808   }
 809
 810   //The GetEdgeNearPoint() doesn't change object so no new function is required.
 811   Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
 812
 813   //Make a Python command
 814   TCollection_AsciiString anEntry, aDescr;
 815   TDF_Tool::Entry(aResult->GetEntry(), anEntry);
 816   aDescr += anEntry + " = IBlocksOperations.GetEdgeNearPoint(";
 817   TDF_Tool::Entry(theShape->GetEntry(), anEntry);
 818   aDescr += anEntry + ", ";
 819   TDF_Tool::Entry(thePoint->GetEntry(), anEntry);
 820   aDescr += anEntry + ")";
 821
 822   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
 823   aNewDescr += aDescr;
 824   aFunction->SetDescription(aNewDescr);
 825
 826   SetErrorCode(OK);
 827   return aResult;
 828 }
 829
 830 //=============================================================================
 831 /*!
 832  *  GetFaceByPoints
 833  */
 834 //=============================================================================
 835 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetFaceByPoints
 836                                                 (Handle(GEOM_Object) theShape,
 837                                                  Handle(GEOM_Object) thePoint1,
 838                                                  Handle(GEOM_Object) thePoint2,
 839                                                  Handle(GEOM_Object) thePoint3,
 840                                                  Handle(GEOM_Object) thePoint4)
 841 {
 842   SetErrorCode(KO);
 843
 844   //New object
 845   Handle(GEOM_Object) aResult;
 846
 847   // Arguments
 848   if (theShape.IsNull() ||
 849       thePoint1.IsNull() || thePoint2.IsNull() ||
 850       thePoint3.IsNull() || thePoint4.IsNull()) return NULL;
 851
 852   TopoDS_Shape aBlockOrComp = theShape->GetValue();
 853   if (aBlockOrComp.IsNull()) {
 854     SetErrorCode("Block or compound is null");
 855     return NULL;
 856   }
 857   if (aBlockOrComp.ShapeType() != TopAbs_SOLID &&
 858       aBlockOrComp.ShapeType() != TopAbs_COMPOUND &&
 859       aBlockOrComp.ShapeType() != TopAbs_COMPSOLID) {
 860     SetErrorCode("Shape is neither a block, nor a compound of blocks");
 861     return NULL;
 862   }
 863
 864   TopoDS_Shape anArg1 = thePoint1->GetValue();
 865   TopoDS_Shape anArg2 = thePoint2->GetValue();
 866   TopoDS_Shape anArg3 = thePoint3->GetValue();
 867   TopoDS_Shape anArg4 = thePoint4->GetValue();
 868   if (anArg1.IsNull() || anArg2.IsNull() ||
 869       anArg3.IsNull() || anArg4.IsNull()) {
 870     SetErrorCode("Null shape is given as argument");
 871     return NULL;
 872   }
 873   if (anArg1.ShapeType() != TopAbs_VERTEX ||
 874       anArg2.ShapeType() != TopAbs_VERTEX ||
 875       anArg3.ShapeType() != TopAbs_VERTEX ||
 876       anArg4.ShapeType() != TopAbs_VERTEX) {
 877     SetErrorCode("Element for face identification is not a vertex");
 878     return NULL;
 879   }
 880
 881   //Compute the Face value
 882   try {
 883     TopoDS_Shape aShape;
 884
 885     TopTools_IndexedDataMapOfShapeListOfShape MVF;
 886     GEOMImpl_Block6Explorer::MapShapesAndAncestors(aBlockOrComp, TopAbs_VERTEX, TopAbs_FACE, MVF);
 887
 888     TopoDS_Shape V1,V2,V3,V4;
 889     Standard_Integer ish, ext = MVF.Extent();
 890
 891     if (MVF.Contains(anArg1)) {
 892       V1 = anArg1;
 893     } else {
 894       for (ish = 1; ish <= ext; ish++) {
 895         TopoDS_Shape aShi = MVF.FindKey(ish);
 896         if (BRepTools::Compare(TopoDS::Vertex(anArg1), TopoDS::Vertex(aShi))) {
 897           V1 = aShi;
 898           break;
 899         }
 900       }
 901     }
 902
 903     if (MVF.Contains(anArg2)) {
 904       V2 = anArg2;
 905     } else {
 906       for (ish = 1; ish <= ext; ish++) {
 907         TopoDS_Shape aShi = MVF.FindKey(ish);
 908         if (BRepTools::Compare(TopoDS::Vertex(anArg2), TopoDS::Vertex(aShi))) {
 909           V2 = aShi;
 910           break;
 911         }
 912       }
 913     }
 914
 915     if (MVF.Contains(anArg3)) {
 916       V3 = anArg3;
 917     } else {
 918       for (ish = 1; ish <= ext; ish++) {
 919         TopoDS_Shape aShi = MVF.FindKey(ish);
 920         if (BRepTools::Compare(TopoDS::Vertex(anArg3), TopoDS::Vertex(aShi))) {
 921           V3 = aShi;
 922           break;
 923         }
 924       }
 925     }
 926
 927     if (MVF.Contains(anArg4)) {
 928       V4 = anArg4;
 929     } else {
 930       for (ish = 1; ish <= ext; ish++) {
 931         TopoDS_Shape aShi = MVF.FindKey(ish);
 932         if (BRepTools::Compare(TopoDS::Vertex(anArg4), TopoDS::Vertex(aShi))) {
 933           V4 = aShi;
 934           break;
 935         }
 936       }
 937     }
 938
 939     if (V1.IsNull() || V2.IsNull() || V3.IsNull() || V4.IsNull()) {
 940       SetErrorCode("The given vertex does not belong to the shape");
 941       return NULL;
 942     }
 943
 944     Standard_Integer isFound =
 945       GEOMImpl_Block6Explorer::FindFace(aShape, V1, V2, V3, V4, MVF, Standard_True);
 946     if (isFound == 0) {
 947       SetErrorCode("The given vertices do not belong to one face of the given shape");
 948       return NULL;
 949     } else if (isFound > 1) {
 950       SetErrorCode("The given vertices belong to several faces of the given shape");
 951       return NULL;
 952     } else {
 953       TopTools_IndexedMapOfShape anIndices;
 954       TopExp::MapShapes(aBlockOrComp, anIndices);
 955       Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
 956       anArray->SetValue(1, anIndices.FindIndex(aShape));
 957       aResult = GetEngine()->AddSubShape(theShape, anArray);
 958     }
 959   }
 960   catch (Standard_Failure) {
 961     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 962     SetErrorCode(aFail->GetMessageString());
 963     return NULL;
 964   }
 965
 966   //The GetFaceByPoints() doesn't change object so no new function is required.
 967   Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
 968
 969   //Make a Python command
 970   TCollection_AsciiString anEntry, aDescr;
 971   TDF_Tool::Entry(aResult->GetEntry(), anEntry);
 972   aDescr += anEntry + " = IBlocksOperations.GetFaceByPoints(";
 973   TDF_Tool::Entry(theShape->GetEntry(), anEntry);
 974   aDescr += anEntry + ", ";
 975   TDF_Tool::Entry(thePoint1->GetEntry(), anEntry);
 976   aDescr += anEntry + ", ";
 977   TDF_Tool::Entry(thePoint2->GetEntry(), anEntry);
 978   aDescr += anEntry + ", ";
 979   TDF_Tool::Entry(thePoint3->GetEntry(), anEntry);
 980   aDescr += anEntry + ", ";
 981   TDF_Tool::Entry(thePoint4->GetEntry(), anEntry);
 982   aDescr += anEntry + ")";
 983
 984   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
 985   aNewDescr += aDescr;
 986   aFunction->SetDescription(aNewDescr);
 987
 988   SetErrorCode(OK);
 989   return aResult;
 990 }
 991
 992 //=============================================================================
 993 /*!
 994  *  GetFaceByEdges
 995  */
 996 //=============================================================================
 997 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetFaceByEdges
 998                                                 (Handle(GEOM_Object) theShape,
 999                                                  Handle(GEOM_Object) theEdge1,
1000                                                  Handle(GEOM_Object) theEdge2)
1001 {
1002   SetErrorCode(KO);
1003
1004   //New object
1005   Handle(GEOM_Object) aResult;
1006
1007   // Arguments
1008   if (theShape.IsNull() || theEdge1.IsNull() || theEdge2.IsNull()) return NULL;
1009
1010   TopoDS_Shape aBlockOrComp = theShape->GetValue();
1011   if (aBlockOrComp.IsNull()) {
1012     SetErrorCode("Block or compound is null");
1013     return NULL;
1014   }
1015   if (aBlockOrComp.ShapeType() != TopAbs_SOLID &&
1016       aBlockOrComp.ShapeType() != TopAbs_COMPOUND &&
1017       aBlockOrComp.ShapeType() != TopAbs_COMPSOLID) {
1018     SetErrorCode("Shape is neither a block, nor a compound of blocks");
1019     return NULL;
1020   }
1021
1022   TopoDS_Shape anArg1 = theEdge1->GetValue();
1023   TopoDS_Shape anArg2 = theEdge2->GetValue();
1024   if (anArg1.IsNull() || anArg2.IsNull()) {
1025     SetErrorCode("Null shape is given as argument");
1026     return NULL;
1027   }
1028   if (anArg1.ShapeType() != TopAbs_EDGE ||
1029       anArg2.ShapeType() != TopAbs_EDGE) {
1030     SetErrorCode("Element for face identification is not an edge");
1031     return NULL;
1032   }
1033
1034   //Compute the Face value
1035   try {
1036     TopoDS_Shape aShape;
1037
1038     TopTools_IndexedDataMapOfShapeListOfShape MEF;
1039     GEOMImpl_Block6Explorer::MapShapesAndAncestors(aBlockOrComp, TopAbs_EDGE, TopAbs_FACE, MEF);
1040
1041     TopoDS_Shape E1,E2;
1042     Standard_Integer ish, ext = MEF.Extent();
1043
1044     if (MEF.Contains(anArg1)) {
1045       E1 = anArg1;
1046     } else {
1047       for (ish = 1; ish <= ext; ish++) {
1048         TopoDS_Shape aShi = MEF.FindKey(ish);
1049         if (GEOMImpl_Block6Explorer::IsSimilarEdges(anArg1, aShi)) {
1050           E1 = aShi;
1051         }
1052       }
1053     }
1054
1055     if (MEF.Contains(anArg2)) {
1056       E2 = anArg2;
1057     } else {
1058       for (ish = 1; ish <= ext; ish++) {
1059         TopoDS_Shape aShi = MEF.FindKey(ish);
1060         if (GEOMImpl_Block6Explorer::IsSimilarEdges(anArg2, aShi)) {
1061           E2 = aShi;
1062         }
1063       }
1064     }
1065
1066     if (E1.IsNull() || E2.IsNull()) {
1067       SetErrorCode("The given edge does not belong to the shape");
1068       return NULL;
1069     }
1070
1071     const TopTools_ListOfShape& aFacesOfE1 = MEF.FindFromKey(E1);
1072     const TopTools_ListOfShape& aFacesOfE2 = MEF.FindFromKey(E2);
1073
1074     Standard_Integer isFound = 0;
1075     TopTools_ListIteratorOfListOfShape anIterF1 (aFacesOfE1);
1076     for (; anIterF1.More(); anIterF1.Next()) {
1077
1078       TopTools_ListIteratorOfListOfShape anIterF2 (aFacesOfE2);
1079       for (; anIterF2.More(); anIterF2.Next()) {
1080
1081         if (anIterF1.Value().IsSame(anIterF2.Value())) {
1082           isFound++;
1083
1084           // Store the face, defined by two edges
1085           aShape = anIterF1.Value();
1086         }
1087       }
1088     }
1089     if (isFound == 0) {
1090       SetErrorCode("The given edges do not belong to one face of the given shape");
1091       return NULL;
1092     } else if (isFound > 1) {
1093       SetErrorCode("The given edges belong to several faces of the given shape");
1094       return NULL;
1095     } else {
1096       TopTools_IndexedMapOfShape anIndices;
1097       TopExp::MapShapes(aBlockOrComp, anIndices);
1098       Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
1099       anArray->SetValue(1, anIndices.FindIndex(aShape));
1100       aResult = GetEngine()->AddSubShape(theShape, anArray);
1101     }
1102   }
1103   catch (Standard_Failure) {
1104     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1105     SetErrorCode(aFail->GetMessageString());
1106     return NULL;
1107   }
1108
1109   //The GetFaceByEdges() doesn't change object so no new function is required.
1110   Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
1111
1112   //Make a Python command
1113   TCollection_AsciiString anEntry, aDescr;
1114   TDF_Tool::Entry(aResult->GetEntry(), anEntry);
1115   aDescr += anEntry + " = IBlocksOperations.GetFaceByEdges(";
1116   TDF_Tool::Entry(theShape->GetEntry(), anEntry);
1117   aDescr += anEntry + ", ";
1118   TDF_Tool::Entry(theEdge1->GetEntry(), anEntry);
1119   aDescr += anEntry + ", ";
1120   TDF_Tool::Entry(theEdge2->GetEntry(), anEntry);
1121   aDescr += anEntry + ")";
1122
1123   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
1124   aNewDescr += aDescr;
1125   aFunction->SetDescription(aNewDescr);
1126
1127   SetErrorCode(OK);
1128   return aResult;
1129 }
1130
1131 //=============================================================================
1132 /*!
1133  *  GetOppositeFace
1134  */
1135 //=============================================================================
1136 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetOppositeFace
1137                                                 (Handle(GEOM_Object) theShape,
1138                                                  Handle(GEOM_Object) theFace)
1139 {
1140   SetErrorCode(KO);
1141
1142   //New object
1143   Handle(GEOM_Object) aResult;
1144
1145   // Arguments
1146   if (theShape.IsNull() || theFace.IsNull()) return NULL;
1147
1148   TopoDS_Shape aBlockOrComp = theShape->GetValue();
1149   if (aBlockOrComp.IsNull()) {
1150     SetErrorCode("Block is null");
1151     return NULL;
1152   }
1153   if (aBlockOrComp.ShapeType() != TopAbs_SOLID) {
1154     SetErrorCode("Shape is not a block");
1155     return NULL;
1156   }
1157
1158   TopoDS_Shape anArg = theFace->GetValue();
1159   if (anArg.IsNull()) {
1160     SetErrorCode("Null shape is given as argument");
1161     return NULL;
1162   }
1163   if (anArg.ShapeType() != TopAbs_FACE) {
1164     SetErrorCode("Element for face identification is not a face");
1165     return NULL;
1166   }
1167
1168   //Compute the Face value
1169   try {
1170     TopoDS_Shape aShape;
1171
1172     GEOMImpl_Block6Explorer aBlockTool;
1173     aBlockTool.InitByBlockAndFace(aBlockOrComp, anArg);
1174     aShape = aBlockTool.GetFace(2);
1175
1176     TopTools_IndexedMapOfShape anIndices;
1177     TopExp::MapShapes(aBlockOrComp, anIndices);
1178     Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
1179     anArray->SetValue(1, anIndices.FindIndex(aShape));
1180     aResult = GetEngine()->AddSubShape(theShape, anArray);
1181   }
1182   catch (Standard_Failure) {
1183     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1184     SetErrorCode(aFail->GetMessageString());
1185     return NULL;
1186   }
1187
1188   //The GetOppositeFace() doesn't change object so no new function is required.
1189   Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
1190
1191   //Make a Python command
1192   TCollection_AsciiString anEntry, aDescr;
1193   TDF_Tool::Entry(aResult->GetEntry(), anEntry);
1194   aDescr += anEntry + " = IBlocksOperations.GetOppositeFace(";
1195   TDF_Tool::Entry(theShape->GetEntry(), anEntry);
1196   aDescr += anEntry + ", ";
1197   TDF_Tool::Entry(theFace->GetEntry(), anEntry);
1198   aDescr += anEntry + ")";
1199
1200   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
1201   aNewDescr += aDescr;
1202   aFunction->SetDescription(aNewDescr);
1203
1204   SetErrorCode(OK);
1205   return aResult;
1206 }
1207
1208 //=============================================================================
1209 /*!
1210  *  GetFaceNearPoint
1211  */
1212 //=============================================================================
1213 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetFaceNearPoint
1214                                                 (Handle(GEOM_Object) theShape,
1215                                                  Handle(GEOM_Object) thePoint)
1216 {
1217   SetErrorCode(KO);
1218
1219   //New object
1220   Handle(GEOM_Object) aResult;
1221
1222   // Arguments
1223   if (theShape.IsNull() || thePoint.IsNull()) return NULL;
1224
1225   TopoDS_Shape aBlockOrComp = theShape->GetValue();
1226   if (aBlockOrComp.IsNull()) {
1227     SetErrorCode("Block or compound is null");
1228     return NULL;
1229   }
1230   if (aBlockOrComp.ShapeType() != TopAbs_SOLID &&
1231       aBlockOrComp.ShapeType() != TopAbs_COMPOUND &&
1232       aBlockOrComp.ShapeType() != TopAbs_COMPSOLID) {
1233     SetErrorCode("Shape is neither a block, nor a compound of blocks");
1234     return NULL;
1235   }
1236
1237   TopoDS_Shape anArg = thePoint->GetValue();
1238   if (anArg.IsNull()) {
1239     SetErrorCode("Null shape is given as argument");
1240     return NULL;
1241   }
1242   if (anArg.ShapeType() != TopAbs_VERTEX) {
1243     SetErrorCode("Element for face identification is not a vertex");
1244     return NULL;
1245   }
1246
1247   //Compute the Face value
1248   try {
1249     TopoDS_Shape aShape;
1250
1251     TopoDS_Vertex aVert = TopoDS::Vertex(anArg);
1252     gp_Pnt aPnt = BRep_Tool::Pnt(aVert);
1253
1254     // 1. Explode blocks on faces
1255     TopTools_MapOfShape mapShape;
1256     Standard_Integer nbFaces = 0;
1257     TopExp_Explorer exp (aBlockOrComp, TopAbs_FACE);
1258     for (; exp.More(); exp.Next()) {
1259       if (mapShape.Add(exp.Current())) {
1260         nbFaces++;
1261       }
1262     }
1263
1264     mapShape.Clear();
1265     Standard_Integer ind = 1;
1266     TopTools_Array1OfShape aFaces (1, nbFaces);
1267     TColStd_Array1OfInteger aDistances (1, nbFaces);
1268     for (exp.Init(aBlockOrComp, TopAbs_FACE); exp.More(); exp.Next()) {
1269       if (mapShape.Add(exp.Current())) {
1270         TopoDS_Shape aFace = exp.Current();
1271         aFaces(ind) = aFace;
1272
1273         // 2. Classify the point relatively each face
1274         BRepClass_FaceClassifier FC (TopoDS::Face(aFace), aPnt, Precision::Confusion());
1275         if (FC.State() == TopAbs_IN) {
1276           aDistances(ind) = -1;
1277         } else if (FC.State() == TopAbs_ON) {
1278           aDistances(ind) = 0;
1279         } else { // OUT
1280           aDistances(ind) = 1;
1281         }
1282         ind++;
1283       }
1284     }
1285
1286     // 3. Define face, containing the point or having minimum distance to it
1287     Standard_Integer nearest = 2, nbFound = 0;
1288     for (ind = 1; ind <= nbFaces; ind++) {
1289       if (aDistances(ind) < nearest) {
1290         nearest = aDistances(ind);
1291         aShape = aFaces(ind);
1292         nbFound = 1;
1293       } else if (aDistances(ind) == nearest) {
1294         nbFound++;
1295       } else {
1296       }
1297     }
1298     if (nbFound > 1) {
1299       if (nearest == 0) {
1300         // The point is on boundary of some faces and there are
1301         // no faces, having the point inside
1302         SetErrorCode("Multiple faces near the given point are found");
1303         return NULL;
1304
1305       } else if (nearest == 1) {
1306         // The point is outside some faces and there are
1307         // no faces, having the point inside or on boundary.
1308         // We will get a nearest face
1309         Standard_Real minDist = RealLast();
1310         for (ind = 1; ind <= nbFaces; ind++) {
1311           if (aDistances(ind) == 1) {
1312             BRepExtrema_DistShapeShape aDistTool (aVert, aFaces(ind));
1313             if (!aDistTool.IsDone()) {
1314               SetErrorCode("Can not find a distance from the given point to one of faces");
1315               return NULL;
1316             }
1317             Standard_Real aDist = aDistTool.Value();
1318             if (aDist < minDist) {
1319               minDist = aDist;
1320               aShape = aFaces(ind);
1321             }
1322           }
1323         }
1324       } else { // nearest == -1
1325         // The point is inside some faces.
1326         // We will get a face with nearest center
1327         Standard_Real minDist = RealLast();
1328         for (ind = 1; ind <= nbFaces; ind++) {
1329           if (aDistances(ind) == -1) {
1330             GProp_GProps aSystem;
1331             BRepGProp::SurfaceProperties(aFaces(ind), aSystem);
1332             gp_Pnt aCenterMass = aSystem.CentreOfMass();
1333
1334             Standard_Real aDist = aCenterMass.Distance(aPnt);
1335             if (aDist < minDist) {
1336               minDist = aDist;
1337               aShape = aFaces(ind);
1338             }
1339           }
1340         }
1341       }
1342     }
1343
1344     if (nbFound == 0) {
1345       SetErrorCode("There are no faces near the given point");
1346       return NULL;
1347     } else {
1348       TopTools_IndexedMapOfShape anIndices;
1349       TopExp::MapShapes(aBlockOrComp, anIndices);
1350       Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
1351       anArray->SetValue(1, anIndices.FindIndex(aShape));
1352       aResult = GetEngine()->AddSubShape(theShape, anArray);
1353     }
1354   }
1355   catch (Standard_Failure) {
1356     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1357     SetErrorCode(aFail->GetMessageString());
1358     return NULL;
1359   }
1360
1361   //The GetFaceNearPoint() doesn't change object so no new function is required.
1362   Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
1363
1364   //Make a Python command
1365   TCollection_AsciiString anEntry, aDescr;
1366   TDF_Tool::Entry(aResult->GetEntry(), anEntry);
1367   aDescr += anEntry + " = IBlocksOperations.GetFaceNearPoint(";
1368   TDF_Tool::Entry(theShape->GetEntry(), anEntry);
1369   aDescr += anEntry + ", ";
1370   TDF_Tool::Entry(thePoint->GetEntry(), anEntry);
1371   aDescr += anEntry + ")";
1372
1373   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
1374   aNewDescr += aDescr;
1375   aFunction->SetDescription(aNewDescr);
1376
1377   SetErrorCode(OK);
1378   return aResult;
1379 }
1380
1381 //=============================================================================
1382 /*!
1383  *  GetFaceByNormale
1384  */
1385 //=============================================================================
1386 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetFaceByNormale
1387                                                 (Handle(GEOM_Object) theShape,
1388                                                  Handle(GEOM_Object) theVector)
1389 {
1390   SetErrorCode(KO);
1391
1392   //New object
1393   Handle(GEOM_Object) aResult;
1394
1395   // Arguments
1396   if (theShape.IsNull() || theVector.IsNull()) return NULL;
1397
1398   TopoDS_Shape aBlockOrComp = theShape->GetValue();
1399   if (aBlockOrComp.IsNull()) {
1400     SetErrorCode("Block or compound is null");
1401     return NULL;
1402   }
1403   if (aBlockOrComp.ShapeType() != TopAbs_SOLID &&
1404       aBlockOrComp.ShapeType() != TopAbs_COMPOUND &&
1405       aBlockOrComp.ShapeType() != TopAbs_COMPSOLID) {
1406     SetErrorCode("Shape is neither a block, nor a compound of blocks");
1407     return NULL;
1408   }
1409
1410   TopoDS_Shape anArg = theVector->GetValue();
1411   if (anArg.IsNull()) {
1412     SetErrorCode("Null shape is given as argument");
1413     return NULL;
1414   }
1415   if (anArg.ShapeType() != TopAbs_EDGE) {
1416     SetErrorCode("Element for normale identification is not an edge");
1417     return NULL;
1418   }
1419
1420   //Compute the Face value
1421   try {
1422     TopoDS_Shape aShape;
1423
1424     TopoDS_Edge anEdge = TopoDS::Edge(anArg);
1425     TopoDS_Vertex V1, V2;
1426     TopExp::Vertices(anEdge, V1, V2, Standard_True);
1427     gp_Pnt P1 = BRep_Tool::Pnt(V1);
1428     gp_Pnt P2 = BRep_Tool::Pnt(V2);
1429     gp_Vec aVec (P1, P2);
1430     if (aVec.Magnitude() < Precision::Confusion()) {
1431       SetErrorCode("Vector with null magnitude is given");
1432       return NULL;
1433     }
1434
1435     Standard_Real minAngle = RealLast();
1436     TopTools_MapOfShape mapShape;
1437     TopExp_Explorer exp (aBlockOrComp, TopAbs_FACE);
1438     for (; exp.More(); exp.Next()) {
1439       if (mapShape.Add(exp.Current())) {
1440         TopoDS_Face aFace = TopoDS::Face(exp.Current());
1441         BRepAdaptor_Surface SF (aFace);
1442
1443         Standard_Real u, v, x;
1444
1445         // find a point on the surface to get normal direction in
1446         u = SF.FirstUParameter();
1447         x = SF.LastUParameter();
1448         if (Precision::IsInfinite(u)) {
1449           u =  (Precision::IsInfinite(x)) ? 0. : x;
1450         } else if (!Precision::IsInfinite(x)) {
1451           u = (u+x) / 2.;
1452         }
1453
1454         v = SF.FirstVParameter();
1455         x = SF.LastVParameter();
1456         if (Precision::IsInfinite(v)) {
1457           v =  (Precision::IsInfinite(x)) ? 0. : x;
1458         } else if (!Precision::IsInfinite(x)) {
1459           v = (v+x) / 2.;
1460         }
1461
1462         // compute the normal direction
1463         gp_Vec Vec1,Vec2;
1464         SF.D1(u,v,P1,Vec1,Vec2);
1465         gp_Vec V = Vec1.Crossed(Vec2);
1466         x = V.Magnitude();
1467         if (V.Magnitude() < Precision::Confusion()) {
1468           SetErrorCode("Normal vector of a face has null magnitude");
1469           return NULL;
1470         }
1471
1472         // consider the face orientation
1473         if (aFace.Orientation() == TopAbs_REVERSED ||
1474             aFace.Orientation() == TopAbs_INTERNAL) {
1475           V = - V;
1476         }
1477
1478         // compute the angle and compare with the minimal one
1479         Standard_Real anAngle = aVec.Angle(V);
1480         if (anAngle < minAngle) {
1481           minAngle = anAngle;
1482           aShape = aFace;
1483         }
1484       }
1485     }
1486
1487     if (aShape.IsNull()) {
1488       SetErrorCode("Failed to find a face by the given normale");
1489       return NULL;
1490     } else {
1491       TopTools_IndexedMapOfShape anIndices;
1492       TopExp::MapShapes(aBlockOrComp, anIndices);
1493       Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
1494       anArray->SetValue(1, anIndices.FindIndex(aShape));
1495       aResult = GetEngine()->AddSubShape(theShape, anArray);
1496     }
1497   }
1498   catch (Standard_Failure) {
1499     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1500     SetErrorCode(aFail->GetMessageString());
1501     return NULL;
1502   }
1503
1504   //The GetFaceByNormale() doesn't change object so no new function is required.
1505   Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
1506
1507   //Make a Python command
1508   TCollection_AsciiString anEntry, aDescr;
1509   TDF_Tool::Entry(aResult->GetEntry(), anEntry);
1510   aDescr += anEntry + " = IBlocksOperations.GetFaceByNormale(";
1511   TDF_Tool::Entry(theShape->GetEntry(), anEntry);
1512   aDescr += anEntry + ", ";
1513   TDF_Tool::Entry(theVector->GetEntry(), anEntry);
1514   aDescr += anEntry + ")";
1515
1516   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
1517   aNewDescr += aDescr;
1518   aFunction->SetDescription(aNewDescr);
1519
1520   SetErrorCode(OK);
1521   return aResult;
1522 }
1523
1524 //=============================================================================
1525 /*!
1526  *  IsCompoundOfBlocks
1527  */
1528 //=============================================================================
1529 Standard_Boolean GEOMImpl_IBlocksOperations::IsCompoundOfBlocks
1530                                                 (Handle(GEOM_Object)    theCompound,
1531                                                  const Standard_Integer theMinNbFaces,
1532                                                  const Standard_Integer theMaxNbFaces,
1533                                                  Standard_Integer&      theNbBlocks)
1534 {
1535   SetErrorCode(KO);
1536   Standard_Boolean isCompOfBlocks = Standard_False;
1537   theNbBlocks = 0;
1538
1539   if (theCompound.IsNull()) return isCompOfBlocks;
1540   TopoDS_Shape aBlockOrComp = theCompound->GetValue();
1541
1542   //Check
1543   isCompOfBlocks = Standard_True;
1544   try {
1545     TopTools_MapOfShape mapShape;
1546     TopExp_Explorer exp (aBlockOrComp, TopAbs_SOLID);
1547     for (; exp.More(); exp.Next()) {
1548       if (mapShape.Add(exp.Current())) {
1549         TopoDS_Shape aSolid = exp.Current();
1550
1551         TopTools_MapOfShape mapFaces;
1552         TopExp_Explorer expF (aSolid, TopAbs_FACE);
1553         Standard_Integer nbFaces = 0;
1554         for (; expF.More(); expF.Next()) {
1555           if (mapFaces.Add(expF.Current())) {
1556             nbFaces++;
1557             if (nbFaces > theMaxNbFaces) {
1558               isCompOfBlocks = Standard_False;
1559               break;
1560             }
1561           }
1562         }
1563         if (nbFaces < theMinNbFaces || theMaxNbFaces < nbFaces) {
1564           isCompOfBlocks = Standard_False;
1565         } else {
1566           theNbBlocks++;
1567         }
1568       }
1569     }
1570   }
1571   catch (Standard_Failure) {
1572     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1573     SetErrorCode(aFail->GetMessageString());
1574     return isCompOfBlocks;
1575   }
1576
1577   SetErrorCode(OK);
1578   return isCompOfBlocks;
1579 }
1580
1581 //=============================================================================
1582 /*!
1583  *  Set of functions, used by CheckCompoundOfBlocks() method
1584  */
1585 //=============================================================================
1586 void AddBlocksFrom (const TopoDS_Shape&  theShape,
1587                     TopTools_ListOfShape& BLO,
1588                     TopTools_ListOfShape& NOT)
1589 {
1590   TopAbs_ShapeEnum aType = theShape.ShapeType();
1591   switch (aType) {
1592   case TopAbs_COMPOUND:
1593   case TopAbs_COMPSOLID:
1594     {
1595       TopoDS_Iterator It (theShape);
1596       for (; It.More(); It.Next()) {
1597         AddBlocksFrom(It.Value(), BLO, NOT);
1598       }
1599     }
1600     break;
1601   case TopAbs_SOLID:
1602     {
1603       TopTools_MapOfShape mapFaces;
1604       TopExp_Explorer expF (theShape, TopAbs_FACE);
1605       Standard_Integer nbFaces = 0;
1606       Standard_Integer nbEdges = 0;
1607       for (; expF.More(); expF.Next()) {
1608         if (mapFaces.Add(expF.Current())) {
1609           nbFaces++;
1610           if (nbFaces > 6) break;
1611
1612           // Check number of edges in the face
1613           TopoDS_Shape aF = expF.Current();
1614           TopExp_Explorer expE (aF, TopAbs_EDGE);
1615           nbEdges = 0;
1616           for (; expE.More(); expE.Next()) {
1617             nbEdges++;
1618             if (nbEdges > 4) break;
1619           }
1620           if (nbEdges != 4) break;
1621         }
1622       }
1623       if (nbFaces == 6 && nbEdges == 4) {
1624         BLO.Append(theShape);
1625       } else {
1626         NOT.Append(theShape);
1627       }
1628     }
1629     break;
1630   default:
1631     NOT.Append(theShape);
1632   }
1633 }
1634
1635 #define REL_NOT_CONNECTED 0
1636 #define REL_OK            1
1637 #define REL_NOT_GLUED     2
1638 #define REL_COLLISION_VV  3
1639 #define REL_COLLISION_FF  4
1640 #define REL_COLLISION_EE  5
1641 #define REL_UNKNOWN       6
1642
1643 Standard_Integer BlocksRelation (const TopoDS_Shape& theBlock1,
1644                                  const TopoDS_Shape& theBlock2)
1645 {
1646   // Compare bounding boxes before calling BRepExtrema_DistShapeShape
1647   Standard_Real Xmin1, Ymin1, Zmin1, Xmax1, Ymax1, Zmax1;
1648   Standard_Real Xmin2, Ymin2, Zmin2, Xmax2, Ymax2, Zmax2;
1649   Bnd_Box B1, B2;
1650   BRepBndLib::Add(theBlock1, B1);
1651   BRepBndLib::Add(theBlock2, B2);
1652 //  BRepBndLib::AddClose(theBlock1, B1);
1653 //  BRepBndLib::AddClose(theBlock2, B2);
1654   B1.Get(Xmin1, Ymin1, Zmin1, Xmax1, Ymax1, Zmax1);
1655   B2.Get(Xmin2, Ymin2, Zmin2, Xmax2, Ymax2, Zmax2);
1656   if (Xmax2 < Xmin1 || Xmax1 < Xmin2 ||
1657       Ymax2 < Ymin1 || Ymax1 < Ymin2 ||
1658       Zmax2 < Zmin1 || Zmax1 < Zmin2) {
1659 //  Standard_Real prec = Precision::Confusion();
1660 //  if (prec < Xmin1 - Xmax2 || prec < Xmin2 - Xmax1 ||
1661 //      prec < Ymin1 - Ymax2 || prec < Ymin2 - Ymax1 ||
1662 //      prec < Zmin1 - Zmax2 || prec < Zmin2 - Zmax1) {
1663     return REL_NOT_CONNECTED;
1664   }
1665   // to be done
1666
1667   BRepExtrema_DistShapeShape dst (theBlock1, theBlock2);
1668   if (!dst.IsDone()) {
1669     return REL_UNKNOWN;
1670   }
1671
1672   if (dst.Value() > Precision::Confusion()) {
1673     return REL_NOT_CONNECTED;
1674   }
1675
1676   if (dst.InnerSolution()) {
1677     return REL_COLLISION_VV;
1678   }
1679
1680   Standard_Integer nbSol = dst.NbSolution();
1681   Standard_Integer relation = REL_OK;
1682   Standard_Integer nbVerts = 0;
1683   Standard_Integer nbEdges = 0;
1684   Standard_Integer sol = 1;
1685   for (; sol <= nbSol; sol++) {
1686     BRepExtrema_SupportType supp1 = dst.SupportTypeShape1(sol);
1687     BRepExtrema_SupportType supp2 = dst.SupportTypeShape2(sol);
1688     if (supp1 == BRepExtrema_IsVertex && supp2 == BRepExtrema_IsVertex) {
1689       nbVerts++;
1690     } else if (supp1 == BRepExtrema_IsInFace || supp2 == BRepExtrema_IsInFace) {
1691       return REL_COLLISION_FF;
1692     } else if (supp1 == BRepExtrema_IsOnEdge && supp2 == BRepExtrema_IsOnEdge) {
1693       nbEdges++;
1694     } else if ((supp1 == BRepExtrema_IsOnEdge && supp2 == BRepExtrema_IsVertex) ||
1695                (supp2 == BRepExtrema_IsOnEdge && supp1 == BRepExtrema_IsVertex)) {
1696       relation = REL_COLLISION_EE;
1697     } else {
1698     }
1699   }
1700
1701   if (relation != REL_OK) {
1702     return relation;
1703   }
1704
1705   TColStd_Array1OfInteger vertSol (1, nbVerts);
1706   TopTools_Array1OfShape V1 (1, nbVerts);
1707   TopTools_Array1OfShape V2 (1, nbVerts);
1708   Standard_Integer ivs = 0;
1709   for (sol = 1; sol <= nbSol; sol++) {
1710     if (dst.SupportTypeShape1(sol) == BRepExtrema_IsVertex &&
1711         dst.SupportTypeShape2(sol) == BRepExtrema_IsVertex) {
1712       TopoDS_Vertex Vcur = TopoDS::Vertex(dst.SupportOnShape1(sol));
1713       // Check, that this vertex is far enough from other solution vertices.
1714       Standard_Integer ii = 1;
1715       for (; ii <= ivs; ii++) {
1716         if (BRepTools::Compare(TopoDS::Vertex(V1(ii)), Vcur)) {
1717           continue;
1718         }
1719       }
1720       ivs++;
1721       vertSol(ivs) = sol;
1722       V1(ivs) = Vcur;
1723       V2(ivs) = dst.SupportOnShape2(sol);
1724     }
1725   }
1726
1727   // As we deal only with quadrangles,
1728   // 2, 3 or 4 vertex solutions can be found.
1729   if (ivs <= 1) {
1730     if (nbEdges > 0) {
1731       return REL_COLLISION_FF;
1732     }
1733     return REL_NOT_CONNECTED;
1734   }
1735   if (ivs > 4) {
1736     return REL_UNKNOWN;
1737   }
1738
1739   // Check sharing of coincident entities.
1740   if (ivs == 2 || ivs == 3) {
1741     // Map vertices and edges of the blocks
1742     TopTools_IndexedDataMapOfShapeListOfShape MVE1, MVE2;
1743     GEOMImpl_Block6Explorer::MapShapesAndAncestors
1744       (theBlock1, TopAbs_VERTEX, TopAbs_EDGE, MVE1);
1745     GEOMImpl_Block6Explorer::MapShapesAndAncestors
1746       (theBlock2, TopAbs_VERTEX, TopAbs_EDGE, MVE2);
1747
1748     if (ivs == 2) {
1749       // Find common edge
1750       TopoDS_Shape anEdge1, anEdge2;
1751       GEOMImpl_Block6Explorer::FindEdge(anEdge1, V1(1), V1(2), MVE1);
1752       if (anEdge1.IsNull()) return REL_UNKNOWN;
1753
1754       GEOMImpl_Block6Explorer::FindEdge(anEdge2, V2(1), V2(2), MVE2);
1755       if (anEdge2.IsNull()) return REL_UNKNOWN;
1756
1757       if (!anEdge1.IsSame(anEdge2)) return REL_NOT_GLUED;
1758
1759     } else { // ivs == 3
1760       // Find common edges
1761       Standard_Integer e1_v1 = 1;
1762       Standard_Integer e1_v2 = 2;
1763       Standard_Integer e2_v1 = 3;
1764       Standard_Integer e2_v2 = 1;
1765
1766       TopoDS_Shape anEdge11, anEdge12;
1767       GEOMImpl_Block6Explorer::FindEdge(anEdge11, V1(e1_v1), V1(e1_v2), MVE1);
1768       if (anEdge11.IsNull()) {
1769         e1_v2 = 3;
1770         e2_v1 = 2;
1771         GEOMImpl_Block6Explorer::FindEdge(anEdge11, V1(e1_v1), V1(e1_v2), MVE1);
1772         if (anEdge11.IsNull()) return REL_UNKNOWN;
1773       }
1774       GEOMImpl_Block6Explorer::FindEdge(anEdge12, V1(e2_v1), V1(e2_v2), MVE1);
1775       if (anEdge12.IsNull()) {
1776         e2_v2 = 5 - e2_v1;
1777         GEOMImpl_Block6Explorer::FindEdge(anEdge12, V1(e2_v1), V1(e2_v2), MVE1);
1778         if (anEdge12.IsNull()) return REL_UNKNOWN;
1779       }
1780
1781       TopoDS_Shape anEdge21, anEdge22;
1782       GEOMImpl_Block6Explorer::FindEdge(anEdge21, V2(e1_v1), V2(e1_v2), MVE2);
1783       if (anEdge21.IsNull()) return REL_UNKNOWN;
1784       GEOMImpl_Block6Explorer::FindEdge(anEdge22, V2(e2_v1), V2(e2_v2), MVE2);
1785       if (anEdge22.IsNull()) return REL_UNKNOWN;
1786
1787       // Check of edges coincidence (with some precision) have to be done here
1788       // if (!anEdge11.IsEqual(anEdge21)) return REL_UNKNOWN;
1789       // if (!anEdge12.IsEqual(anEdge22)) return REL_UNKNOWN;
1790
1791       // Check of edges sharing
1792       if (!anEdge11.IsSame(anEdge21)) return REL_NOT_GLUED;
1793       if (!anEdge12.IsSame(anEdge22)) return REL_NOT_GLUED;
1794     }
1795   }
1796
1797   if (ivs == 4) {
1798     // Map vertices and faces of the blocks
1799     TopTools_IndexedDataMapOfShapeListOfShape MVF1, MVF2;
1800     GEOMImpl_Block6Explorer::MapShapesAndAncestors
1801       (theBlock1, TopAbs_VERTEX, TopAbs_FACE, MVF1);
1802     GEOMImpl_Block6Explorer::MapShapesAndAncestors
1803       (theBlock2, TopAbs_VERTEX, TopAbs_FACE, MVF2);
1804
1805     TopoDS_Shape aFace1, aFace2;
1806     GEOMImpl_Block6Explorer::FindFace(aFace1, V1(1), V1(2), V1(3), V1(4), MVF1);
1807     if (aFace1.IsNull()) return REL_UNKNOWN;
1808     GEOMImpl_Block6Explorer::FindFace(aFace2, V2(1), V2(2), V2(3), V2(4), MVF2);
1809     if (aFace2.IsNull()) return REL_UNKNOWN;
1810
1811     // Check of faces coincidence (with some precision) have to be done here
1812     // if (!aFace1.IsEqual(aFace2)) return REL_UNKNOWN;
1813
1814     // Check of faces sharing
1815     if (!aFace1.IsSame(aFace2)) return REL_NOT_GLUED;
1816   }
1817
1818   return REL_OK;
1819 }
1820
1821 void FindConnected (const Standard_Integer         theBlockIndex,
1822                     const TColStd_Array2OfInteger& theRelations,
1823                     TColStd_MapOfInteger&          theProcessedMap,
1824                     TColStd_MapOfInteger&          theConnectedMap)
1825 {
1826   theConnectedMap.Add(theBlockIndex);
1827   theProcessedMap.Add(theBlockIndex);
1828
1829   Standard_Integer nbBlocks = theRelations.ColLength();
1830   Standard_Integer col = 1;
1831   for (; col <= nbBlocks; col++) {
1832     if (theRelations(theBlockIndex, col) == REL_OK ||
1833         theRelations(theBlockIndex, col) == REL_NOT_GLUED) {
1834       if (!theProcessedMap.Contains(col)) {
1835         FindConnected(col, theRelations, theProcessedMap, theConnectedMap);
1836       }
1837     }
1838   }
1839 }
1840
1841 Standard_Boolean HasAnyConnection (const Standard_Integer         theBlockIndex,
1842                                    const TColStd_MapOfInteger&    theWith,
1843                                    const TColStd_Array2OfInteger& theRelations,
1844                                    TColStd_MapOfInteger&          theProcessedMap)
1845 {
1846   theProcessedMap.Add(theBlockIndex);
1847
1848   Standard_Integer nbBlocks = theRelations.ColLength();
1849   Standard_Integer col = 1;
1850   for (; col <= nbBlocks; col++) {
1851     if (theRelations(theBlockIndex, col) != REL_NOT_CONNECTED) {
1852       if (!theProcessedMap.Contains(col)) {
1853         if (theWith.Contains(col))
1854           return Standard_True;
1855         if (HasAnyConnection(col, theWith, theRelations, theProcessedMap))
1856           return Standard_True;
1857       }
1858     }
1859   }
1860
1861   return Standard_False;
1862 }
1863
1864 //=============================================================================
1865 /*!
1866  *  CheckCompoundOfBlocks
1867  */
1868 //=============================================================================
1869 Standard_Boolean GEOMImpl_IBlocksOperations::CheckCompoundOfBlocks
1870                                                 (Handle(GEOM_Object) theCompound,
1871                                                  list<BCError>&      theErrors)
1872 {
1873   SetErrorCode(KO);
1874
1875   if (theCompound.IsNull()) return Standard_False;
1876   TopoDS_Shape aBlockOrComp = theCompound->GetValue();
1877
1878   Standard_Boolean isCompOfBlocks = Standard_True;
1879
1880   // Map sub-shapes and their indices
1881   TopTools_IndexedMapOfShape anIndices;
1882   TopExp::MapShapes(aBlockOrComp, anIndices);
1883
1884   // 1. Report non-blocks
1885   TopTools_ListOfShape NOT; // Not blocks
1886   TopTools_ListOfShape BLO; // All blocks from the given compound
1887   AddBlocksFrom(aBlockOrComp, BLO, NOT);
1888
1889   if (NOT.Extent() > 0) {
1890     isCompOfBlocks = Standard_False;
1891     BCError anErr;
1892     anErr.error = NOT_BLOCK;
1893     TopTools_ListIteratorOfListOfShape NOTit (NOT);
1894     for (; NOTit.More(); NOTit.Next()) {
1895       anErr.incriminated.push_back(anIndices.FindIndex(NOTit.Value()));
1896     }
1897     theErrors.push_back(anErr);
1898   }
1899
1900   Standard_Integer nbBlocks = BLO.Extent();
1901   if (nbBlocks == 0) {
1902     isCompOfBlocks = Standard_False;
1903     SetErrorCode(OK);
1904     return isCompOfBlocks;
1905   }
1906   if (nbBlocks == 1) {
1907     SetErrorCode(OK);
1908     return isCompOfBlocks;
1909   }
1910
1911   // Convert list of blocks into array for easy and fast access
1912   Standard_Integer ibl = 1;
1913   TopTools_Array1OfShape aBlocks (1, nbBlocks);
1914   TopTools_ListIteratorOfListOfShape BLOit (BLO);
1915   for (; BLOit.More(); BLOit.Next(), ibl++) {
1916     aBlocks.SetValue(ibl, BLOit.Value());
1917   }
1918
1919   // 2. Find relations between all blocks,
1920   //    report connection errors (NOT_GLUED and INVALID_CONNECTION)
1921   TColStd_Array2OfInteger aRelations (1, nbBlocks, 1, nbBlocks);
1922   aRelations.Init(REL_NOT_CONNECTED);
1923
1924   Standard_Integer row = 1;
1925   for (row = 1; row <= nbBlocks; row++) {
1926     TopoDS_Shape aBlock = aBlocks.Value(row);
1927
1928     Standard_Integer col = row + 1;
1929     for (; col <= nbBlocks; col++) {
1930       Standard_Integer aRel = BlocksRelation(aBlock, aBlocks.Value(col));
1931       if (aRel != REL_NOT_CONNECTED) {
1932         aRelations.SetValue(row, col, aRel);
1933         aRelations.SetValue(col, row, aRel);
1934         if (aRel == REL_NOT_GLUED) {
1935           // report connection error
1936           isCompOfBlocks = Standard_False;
1937           BCError anErr;
1938           anErr.error = NOT_GLUED;
1939           anErr.incriminated.push_back(anIndices.FindIndex(aBlocks.Value(row)));
1940           anErr.incriminated.push_back(anIndices.FindIndex(aBlocks.Value(col)));
1941           theErrors.push_back(anErr);
1942         } else if (aRel == REL_COLLISION_VV ||
1943                    aRel == REL_COLLISION_FF ||
1944                    aRel == REL_COLLISION_EE ||
1945                    aRel == REL_UNKNOWN) {
1946           // report connection error
1947           isCompOfBlocks = Standard_False;
1948           BCError anErr;
1949           anErr.error = INVALID_CONNECTION;
1950           anErr.incriminated.push_back(anIndices.FindIndex(aBlocks.Value(row)));
1951           anErr.incriminated.push_back(anIndices.FindIndex(aBlocks.Value(col)));
1952           theErrors.push_back(anErr);
1953         } else {
1954         }
1955       }
1956     }
1957   }
1958
1959   // 3. Find largest set of connected (good connection or not glued) blocks
1960   TColStd_MapOfInteger aProcessedMap;
1961   TColStd_MapOfInteger aLargestSet;
1962   TColStd_MapOfInteger aCurrentSet;
1963   for (ibl = 1; ibl <= nbBlocks; ibl++) {
1964     if (!aProcessedMap.Contains(ibl)) {
1965       FindConnected(ibl, aRelations, aProcessedMap, aCurrentSet);
1966       if (aCurrentSet.Extent() > aLargestSet.Extent()) {
1967         aLargestSet = aCurrentSet;
1968       }
1969     }
1970   }
1971
1972   // 4. Report all blocks, isolated from <aLargestSet>
1973   BCError anErr;
1974   anErr.error = NOT_CONNECTED;
1975   Standard_Boolean hasIsolated = Standard_False;
1976   for (ibl = 1; ibl <= nbBlocks; ibl++) {
1977     if (!aLargestSet.Contains(ibl)) {
1978       aProcessedMap.Clear();
1979       if (!HasAnyConnection(ibl, aLargestSet, aRelations, aProcessedMap)) {
1980         // report connection absence
1981         hasIsolated = Standard_True;
1982         anErr.incriminated.push_back(anIndices.FindIndex(aBlocks.Value(ibl)));
1983       }
1984     }
1985   }
1986   if (hasIsolated) {
1987     isCompOfBlocks = Standard_False;
1988     theErrors.push_back(anErr);
1989   }
1990
1991   SetErrorCode(OK);
1992   return isCompOfBlocks;
1993 }
1994
1995 //=============================================================================
1996 /*!
1997  *  PrintBCErrors
1998  */
1999 //=============================================================================
2000 TCollection_AsciiString GEOMImpl_IBlocksOperations::PrintBCErrors
2001                                                 (Handle(GEOM_Object)  theCompound,
2002                                                  const list<BCError>& theErrors)
2003 {
2004   TCollection_AsciiString aDescr;
2005
2006   list<BCError>::const_iterator errIt = theErrors.begin();
2007   int i = 0;
2008   for (; errIt != theErrors.end(); i++, errIt++) {
2009     BCError errStruct = *errIt;
2010
2011     switch (errStruct.error) {
2012     case NOT_BLOCK:
2013       aDescr += "\nNot a Blocks: ";
2014       break;
2015     case INVALID_CONNECTION:
2016       aDescr += "\nInvalid connection between two blocks: ";
2017       break;
2018     case NOT_CONNECTED:
2019       aDescr += "\nBlocks, not connected with main body: ";
2020       break;
2021     case NOT_GLUED:
2022       aDescr += "\nNot glued blocks: ";
2023       break;
2024     default:
2025       break;
2026     }
2027
2028     list<int> sshList = errStruct.incriminated;
2029     list<int>::iterator sshIt = sshList.begin();
2030     int jj = 0;
2031     for (; sshIt != sshList.end(); jj++, sshIt++) {
2032       if (jj > 0)
2033         aDescr += ", ";
2034       aDescr += TCollection_AsciiString(*sshIt);
2035     }
2036   }
2037
2038   return aDescr;
2039 }
2040
2041 //=============================================================================
2042 /*!
2043  *  ExplodeCompoundOfBlocks
2044  */
2045 //=============================================================================
2046 Handle(TColStd_HSequenceOfTransient) GEOMImpl_IBlocksOperations::ExplodeCompoundOfBlocks
2047                                                 (Handle(GEOM_Object)    theCompound,
2048                                                  const Standard_Integer theMinNbFaces,
2049                                                  const Standard_Integer theMaxNbFaces)
2050 {
2051   SetErrorCode(KO);
2052
2053   if (theCompound.IsNull()) return NULL;
2054   TopoDS_Shape aBlockOrComp = theCompound->GetValue();
2055   if (aBlockOrComp.IsNull()) return NULL;
2056
2057   Handle(TColStd_HSequenceOfTransient) aBlocks = new TColStd_HSequenceOfTransient;
2058   Handle(GEOM_Object) anObj;
2059   Handle(GEOM_Function) aFunction;
2060
2061   TopTools_MapOfShape mapShape;
2062   TCollection_AsciiString anAsciiList = "[", anEntry;
2063
2064   // Map shapes
2065   TopTools_IndexedMapOfShape anIndices;
2066   TopExp::MapShapes(aBlockOrComp, anIndices);
2067   Handle(TColStd_HArray1OfInteger) anArray;
2068
2069   // Explode
2070   try {
2071     TopExp_Explorer exp (aBlockOrComp, TopAbs_SOLID);
2072     for (; exp.More(); exp.Next()) {
2073       if (mapShape.Add(exp.Current())) {
2074         TopoDS_Shape aSolid = exp.Current();
2075
2076         TopTools_MapOfShape mapFaces;
2077         TopExp_Explorer expF (aSolid, TopAbs_FACE);
2078         Standard_Integer nbFaces = 0;
2079         for (; expF.More(); expF.Next()) {
2080           if (mapFaces.Add(expF.Current())) {
2081             nbFaces++;
2082           }
2083         }
2084
2085         if (theMinNbFaces <= nbFaces && nbFaces <= theMaxNbFaces) {
2086           anArray = new TColStd_HArray1OfInteger(1,1);
2087           anArray->SetValue(1, anIndices.FindIndex(aSolid));
2088           anObj = GetEngine()->AddSubShape(theCompound, anArray);
2089           aBlocks->Append(anObj);
2090
2091           //Make a Python command
2092           TDF_Tool::Entry(anObj->GetEntry(), anEntry);
2093           anAsciiList += anEntry;
2094           anAsciiList += ",";
2095         }
2096       }
2097     }
2098   }
2099   catch (Standard_Failure) {
2100     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2101     SetErrorCode(aFail->GetMessageString());
2102     return aBlocks;
2103   }
2104
2105   if (aBlocks->IsEmpty()) {
2106     SetErrorCode("There are no specified blocks in the given shape");
2107     return aBlocks;
2108   }
2109
2110   anAsciiList.Trunc(anAsciiList.Length() - 1);
2111   anAsciiList += "]";
2112
2113   //The explode doesn't change object so no new function is required.
2114   aFunction = theCompound->GetLastFunction();
2115
2116   //Make a Python command
2117   TCollection_AsciiString aDescr (anAsciiList);
2118   aDescr += " = IBlocksOperations.ExplodeCompoundOfBlocks(";
2119   TDF_Tool::Entry(theCompound->GetEntry(), anEntry);
2120   aDescr += anEntry + ", ";
2121   aDescr += TCollection_AsciiString(theMinNbFaces) + ", ";
2122   aDescr += TCollection_AsciiString(theMaxNbFaces) + ")";
2123
2124   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
2125   aNewDescr += aDescr;
2126   aFunction->SetDescription(aNewDescr);
2127
2128   SetErrorCode(OK);
2129   return aBlocks;
2130 }
2131
2132 //=============================================================================
2133 /*!
2134  *  GetBlockNearPoint
2135  */
2136 //=============================================================================
2137 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetBlockNearPoint
2138                                                 (Handle(GEOM_Object) theCompound,
2139                                                  Handle(GEOM_Object) thePoint)
2140 {
2141   SetErrorCode(KO);
2142
2143   //New object
2144   Handle(GEOM_Object) aResult;
2145
2146   // Arguments
2147   if (theCompound.IsNull() || thePoint.IsNull()) return NULL;
2148
2149   TopoDS_Shape aBlockOrComp = theCompound->GetValue();
2150   if (aBlockOrComp.IsNull()) {
2151     SetErrorCode("Compound is null");
2152     return NULL;
2153   }
2154   if (aBlockOrComp.ShapeType() != TopAbs_COMPOUND &&
2155       aBlockOrComp.ShapeType() != TopAbs_COMPSOLID) {
2156     SetErrorCode("Shape is neither a block, nor a compound of blocks");
2157     return NULL;
2158   }
2159
2160   TopoDS_Shape anArg = thePoint->GetValue();
2161   if (anArg.IsNull()) {
2162     SetErrorCode("Null shape is given as argument");
2163     return NULL;
2164   }
2165   if (anArg.ShapeType() != TopAbs_VERTEX) {
2166     SetErrorCode("Element for block identification is not a vertex");
2167     return NULL;
2168   }
2169
2170   //Compute the Block value
2171   try {
2172     TopoDS_Shape aShape;
2173     TopoDS_Vertex aVert = TopoDS::Vertex(anArg);
2174     gp_Pnt aPnt = BRep_Tool::Pnt(aVert);
2175
2176     // 1. Explode compound on blocks
2177     TopTools_MapOfShape mapShape;
2178     Standard_Integer nbSolids = 0;
2179     TopExp_Explorer exp (aBlockOrComp, TopAbs_SOLID);
2180     for (; exp.More(); exp.Next()) {
2181       if (mapShape.Add(exp.Current())) {
2182         nbSolids++;
2183       }
2184     }
2185
2186     mapShape.Clear();
2187     Standard_Integer ind = 1;
2188     TopTools_Array1OfShape aSolids (1, nbSolids);
2189     TColStd_Array1OfInteger aDistances (1, nbSolids);
2190     for (exp.Init(aBlockOrComp, TopAbs_SOLID); exp.More(); exp.Next()) {
2191       if (mapShape.Add(exp.Current())) {
2192         TopoDS_Shape aSolid = exp.Current();
2193         aSolids(ind) = aSolid;
2194
2195         // 2. Classify the point relatively each block
2196         BRepClass3d_SolidClassifier SC (aSolid, aPnt, Precision::Confusion());
2197         if (SC.State() == TopAbs_IN) {
2198           aDistances(ind) = -1;
2199         } else if (SC.State() == TopAbs_ON) {
2200           aDistances(ind) = 0;
2201         } else { // OUT
2202           aDistances(ind) = 1;
2203         }
2204         ind++;
2205       }
2206     }
2207
2208     // 3. Define block, containing the point or having minimum distance to it
2209     Standard_Integer nearest = 2, nbFound = 0;
2210     for (ind = 1; ind <= nbSolids; ind++) {
2211       if (aDistances(ind) < nearest) {
2212         nearest = aDistances(ind);
2213         aShape = aSolids(ind);
2214         nbFound = 1;
2215       } else if (aDistances(ind) == nearest) {
2216         nbFound++;
2217       } else {
2218       }
2219     }
2220     if (nbFound > 1) {
2221       if (nearest == 0) {
2222         // The point is on boundary of some blocks and there are
2223         // no blocks, having the point inside their volume
2224         SetErrorCode("Multiple blocks near the given point are found");
2225         return NULL;
2226
2227       } else if (nearest == 1) {
2228         // The point is outside some blocks and there are
2229         // no blocks, having the point inside or on boundary.
2230         // We will get a nearest block
2231         Standard_Real minDist = RealLast();
2232         for (ind = 1; ind <= nbSolids; ind++) {
2233           if (aDistances(ind) == 1) {
2234             BRepExtrema_DistShapeShape aDistTool (aVert, aSolids(ind));
2235             if (!aDistTool.IsDone()) {
2236               SetErrorCode("Can not find a distance from the given point to one of blocks");
2237               return NULL;
2238             }
2239             Standard_Real aDist = aDistTool.Value();
2240             if (aDist < minDist) {
2241               minDist = aDist;
2242               aShape = aSolids(ind);
2243             }
2244           }
2245         }
2246       } else { // nearest == -1
2247         // The point is inside some blocks.
2248         // We will get a block with nearest center
2249         Standard_Real minDist = RealLast();
2250         for (ind = 1; ind <= nbSolids; ind++) {
2251           if (aDistances(ind) == -1) {
2252             GProp_GProps aSystem;
2253             BRepGProp::VolumeProperties(aSolids(ind), aSystem);
2254             gp_Pnt aCenterMass = aSystem.CentreOfMass();
2255
2256             Standard_Real aDist = aCenterMass.Distance(aPnt);
2257             if (aDist < minDist) {
2258               minDist = aDist;
2259               aShape = aSolids(ind);
2260             }
2261           }
2262         }
2263       }
2264     }
2265
2266     if (nbFound == 0) {
2267       SetErrorCode("There are no blocks near the given point");
2268       return NULL;
2269     } else {
2270       TopTools_IndexedMapOfShape anIndices;
2271       TopExp::MapShapes(aBlockOrComp, anIndices);
2272       Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
2273       anArray->SetValue(1, anIndices.FindIndex(aShape));
2274       aResult = GetEngine()->AddSubShape(theCompound, anArray);
2275     }
2276   }
2277   catch (Standard_Failure) {
2278     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2279     SetErrorCode(aFail->GetMessageString());
2280     return NULL;
2281   }
2282
2283   //The GetBlockNearPoint() doesn't change object so no new function is required.
2284   Handle(GEOM_Function) aFunction = theCompound->GetLastFunction();
2285
2286   //Make a Python command
2287   TCollection_AsciiString anEntry, aDescr;
2288   TDF_Tool::Entry(aResult->GetEntry(), anEntry);
2289   aDescr += anEntry + " = IBlocksOperations.GetBlockNearPoint(";
2290   TDF_Tool::Entry(theCompound->GetEntry(), anEntry);
2291   aDescr += anEntry + ", ";
2292   TDF_Tool::Entry(thePoint->GetEntry(), anEntry);
2293   aDescr += anEntry + ")";
2294
2295   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
2296   aNewDescr += aDescr;
2297   aFunction->SetDescription(aNewDescr);
2298
2299   SetErrorCode(OK);
2300   return aResult;
2301 }
2302
2303 //=============================================================================
2304 /*!
2305  *  GetBlockByParts
2306  */
2307 //=============================================================================
2308 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetBlockByParts
2309                       (Handle(GEOM_Object)                         theCompound,
2310                        const Handle(TColStd_HSequenceOfTransient)& theParts)
2311 {
2312   SetErrorCode(KO);
2313
2314   Handle(GEOM_Object) aResult;
2315
2316   if (theCompound.IsNull() || theParts.IsNull()) return NULL;
2317   TopoDS_Shape aBlockOrComp = theCompound->GetValue();
2318   if (aBlockOrComp.IsNull()) return NULL;
2319
2320   //Get the parts
2321   Standard_Integer argi, aLen = theParts->Length();
2322   TopTools_Array1OfShape anArgs (1, aLen);
2323   TCollection_AsciiString anEntry, aPartsDescr;
2324   for (argi = 1; argi <= aLen; argi++) {
2325     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(theParts->Value(argi));
2326     Handle(GEOM_Function) aRef = anObj->GetLastFunction();
2327     if (aRef.IsNull()) return NULL;
2328
2329     TopoDS_Shape anArg = aRef->GetValue();
2330     if (anArg.IsNull()) {
2331       SetErrorCode("Null shape is given as argument");
2332       return NULL;
2333     }
2334     anArgs(argi) = anArg;
2335
2336     // For Python command
2337     TDF_Tool::Entry(anObj->GetEntry(), anEntry);
2338     if (argi > 1) aPartsDescr += ", ";
2339     aPartsDescr += anEntry;
2340   }
2341
2342   //Compute the Block value
2343   try {
2344     // 1. Explode compound on solids
2345     TopTools_MapOfShape mapShape;
2346     Standard_Integer nbSolids = 0;
2347     TopExp_Explorer exp (aBlockOrComp, TopAbs_SOLID);
2348     for (; exp.More(); exp.Next()) {
2349       if (mapShape.Add(exp.Current())) {
2350         nbSolids++;
2351       }
2352     }
2353
2354     mapShape.Clear();
2355     Standard_Integer ind = 1;
2356     TopTools_Array1OfShape aSolids (1, nbSolids);
2357     TColStd_Array1OfInteger aNbParts (1, nbSolids);
2358     for (exp.Init(aBlockOrComp, TopAbs_SOLID); exp.More(); exp.Next(), ind++) {
2359       if (mapShape.Add(exp.Current())) {
2360         TopoDS_Shape aSolid = exp.Current();
2361         aSolids(ind) = aSolid;
2362         aNbParts(ind) = 0;
2363
2364         // 2. Define quantity of parts, contained in each solid
2365         TopTools_IndexedMapOfShape aSubShapes;
2366         TopExp::MapShapes(aSolid, aSubShapes);
2367         for (argi = 1; argi <= aLen; argi++) {
2368           if (aSubShapes.Contains(anArgs(argi))) {
2369             aNbParts(ind)++;
2370           }
2371         }
2372       }
2373     }
2374
2375     // 3. Define solid, containing maximum quantity of parts
2376     Standard_Integer maxNb = 0, nbFound = 0;
2377     TopoDS_Shape aShape;
2378     for (ind = 1; ind <= nbSolids; ind++) {
2379       if (aNbParts(ind) > maxNb) {
2380         maxNb = aNbParts(ind);
2381         aShape = aSolids(ind);
2382         nbFound = 1;
2383       } else if (aNbParts(ind) == maxNb) {
2384         nbFound++;
2385       } else {
2386       }
2387     }
2388     if (nbFound > 1) {
2389       SetErrorCode("Multiple blocks, containing maximum quantity of the given parts, are found");
2390       return NULL;
2391     } else if (nbFound == 0) {
2392       SetErrorCode("There are no blocks, containing the given parts");
2393       return NULL;
2394     } else {
2395       TopTools_IndexedMapOfShape anIndices;
2396       TopExp::MapShapes(aBlockOrComp, anIndices);
2397       Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
2398       anArray->SetValue(1, anIndices.FindIndex(aShape));
2399       aResult = GetEngine()->AddSubShape(theCompound, anArray);
2400     }
2401   } catch (Standard_Failure) {
2402     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2403     SetErrorCode(aFail->GetMessageString());
2404     return NULL;
2405   }
2406
2407   //The GetBlockByParts() doesn't change object so no new function is required.
2408   Handle(GEOM_Function) aFunction = theCompound->GetLastFunction();
2409
2410   //Make a Python command
2411   TDF_Tool::Entry(aResult->GetEntry(), anEntry);
2412   TCollection_AsciiString aDescr (anEntry);
2413   aDescr += " = IBlocksOperations.GetBlockByParts(";
2414   TDF_Tool::Entry(theCompound->GetEntry(), anEntry);
2415   aDescr += anEntry + ", [";
2416   aDescr += aPartsDescr + "])";
2417
2418   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
2419   aNewDescr += aDescr;
2420   aFunction->SetDescription(aNewDescr);
2421
2422   SetErrorCode(OK);
2423   return aResult;
2424 }
2425
2426 //=============================================================================
2427 /*!
2428  *  GetBlocksByParts
2429  */
2430 //=============================================================================
2431 Handle(TColStd_HSequenceOfTransient) GEOMImpl_IBlocksOperations::GetBlocksByParts
2432                       (Handle(GEOM_Object)                         theCompound,
2433                        const Handle(TColStd_HSequenceOfTransient)& theParts)
2434 {
2435   SetErrorCode(KO);
2436
2437   if (theCompound.IsNull() || theParts.IsNull()) return NULL;
2438   TopoDS_Shape aBlockOrComp = theCompound->GetValue();
2439   if (aBlockOrComp.IsNull()) return NULL;
2440
2441   Handle(TColStd_HSequenceOfTransient) aBlocks = new TColStd_HSequenceOfTransient;
2442   Handle(GEOM_Object) anObj;
2443   Handle(GEOM_Function) aFunction;
2444
2445   //Get the parts
2446   Standard_Integer argi, aLen = theParts->Length();
2447   TopTools_Array1OfShape anArgs (1, aLen);
2448   TCollection_AsciiString anEntry, aPartsDescr, anAsciiList = "[";
2449   for (argi = 1; argi <= aLen; argi++) {
2450     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(theParts->Value(argi));
2451     Handle(GEOM_Function) aRef = anObj->GetLastFunction();
2452     if (aRef.IsNull()) return NULL;
2453
2454     TopoDS_Shape anArg = aRef->GetValue();
2455     if (anArg.IsNull()) {
2456       SetErrorCode("Null shape is given as argument");
2457       return NULL;
2458     }
2459     anArgs(argi) = anArg;
2460
2461     // For Python command
2462     TDF_Tool::Entry(anObj->GetEntry(), anEntry);
2463     if (argi > 1) aPartsDescr += ", ";
2464     aPartsDescr += anEntry;
2465   }
2466
2467   //Get the Blocks
2468   try {
2469     TopTools_MapOfShape mapShape;
2470     Standard_Integer nbSolids = 0;
2471     TopExp_Explorer exp (aBlockOrComp, TopAbs_SOLID);
2472     for (; exp.More(); exp.Next()) {
2473       if (mapShape.Add(exp.Current())) {
2474         nbSolids++;
2475       }
2476     }
2477
2478     mapShape.Clear();
2479     Standard_Integer ind = 1;
2480     TopTools_Array1OfShape aSolids (1, nbSolids);
2481     TColStd_Array1OfInteger aNbParts (1, nbSolids);
2482     for (exp.Init(aBlockOrComp, TopAbs_SOLID); exp.More(); exp.Next(), ind++) {
2483       if (mapShape.Add(exp.Current())) {
2484         TopoDS_Shape aSolid = exp.Current();
2485         aSolids(ind) = aSolid;
2486         aNbParts(ind) = 0;
2487
2488         // 2. Define quantity of parts, contained in each solid
2489         TopTools_IndexedMapOfShape aSubShapes;
2490         TopExp::MapShapes(aSolid, aSubShapes);
2491         for (argi = 1; argi <= aLen; argi++) {
2492           if (aSubShapes.Contains(anArgs(argi))) {
2493             aNbParts(ind)++;
2494           }
2495         }
2496       }
2497     }
2498
2499     // 3. Define solid, containing maximum quantity of parts
2500     Standard_Integer maxNb = 0, nbFound = 0;
2501     for (ind = 1; ind <= nbSolids; ind++) {
2502       if (aNbParts(ind) > maxNb) {
2503         maxNb = aNbParts(ind);
2504         nbFound = 1;
2505       } else if (aNbParts(ind) == maxNb) {
2506         nbFound++;
2507       } else {
2508       }
2509     }
2510     if (nbFound == 0) {
2511       SetErrorCode("There are no blocks, containing the given parts");
2512       return NULL;
2513     }
2514
2515     // Map shapes
2516     TopTools_IndexedMapOfShape anIndices;
2517     TopExp::MapShapes(aBlockOrComp, anIndices);
2518     Handle(TColStd_HArray1OfInteger) anArray;
2519
2520     for (ind = 1; ind <= nbSolids; ind++) {
2521       if (aNbParts(ind) == maxNb) {
2522         anArray = new TColStd_HArray1OfInteger(1,1);
2523         anArray->SetValue(1, anIndices.FindIndex(aSolids(ind)));
2524         anObj = GetEngine()->AddSubShape(theCompound, anArray);
2525         aBlocks->Append(anObj);
2526
2527         //Make a Python command
2528         TDF_Tool::Entry(anObj->GetEntry(), anEntry);
2529         anAsciiList += anEntry;
2530         anAsciiList += ",";
2531       }
2532     }
2533   }
2534   catch (Standard_Failure) {
2535     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2536     SetErrorCode(aFail->GetMessageString());
2537     return NULL;
2538   }
2539
2540   anAsciiList.Trunc(anAsciiList.Length() - 1);
2541   anAsciiList += "]";
2542
2543   //The GetBlocksByParts() doesn't change object so no new function is required.
2544   aFunction = theCompound->GetLastFunction();
2545
2546   //Make a Python command
2547   TCollection_AsciiString aDescr (anAsciiList);
2548   aDescr += " = IBlocksOperations.GetBlocksByParts(";
2549   TDF_Tool::Entry(theCompound->GetEntry(), anEntry);
2550   aDescr += anEntry + ", [";
2551   aDescr += aPartsDescr + "])";
2552
2553   TCollection_AsciiString aNewDescr = aFunction->GetDescription() + "\n";
2554   aNewDescr += aDescr;
2555   aFunction->SetDescription(aNewDescr);
2556
2557   SetErrorCode(OK);
2558   return aBlocks;
2559 }
2560
2561 //=============================================================================
2562 /*!
2563  *  MakeMultiTransformation1D
2564  */
2565 //=============================================================================
2566 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::MakeMultiTransformation1D
2567                                              (Handle(GEOM_Object)    theObject,
2568                                               const Standard_Integer theDirFace1,
2569                                               const Standard_Integer theDirFace2,
2570                                               const Standard_Integer theNbTimes)
2571 {
2572   SetErrorCode(KO);
2573
2574   if (theObject.IsNull()) return NULL;
2575
2576   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
2577   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
2578
2579   //Add a new Copy object
2580   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
2581
2582   //Add a translate function
2583   Handle(GEOM_Function) aFunction =
2584     aCopy->AddFunction(GEOMImpl_BlockDriver::GetID(), BLOCK_MULTI_TRANSFORM_1D);
2585
2586   //Check if the function is set correctly
2587   if (aFunction->GetDriverGUID() != GEOMImpl_BlockDriver::GetID()) return NULL;
2588
2589   GEOMImpl_IBlockTrsf aTI (aFunction);
2590   aTI.SetOriginal(aLastFunction);
2591   aTI.SetFace1U(theDirFace1);
2592   aTI.SetFace2U(theDirFace2);
2593   aTI.SetNbIterU(theNbTimes);
2594
2595   //Compute the transformation
2596   try {
2597     if (!GetSolver()->ComputeFunction(aFunction)) {
2598       SetErrorCode("Block driver failed to make multi-transformation");
2599       return NULL;
2600     }
2601   }
2602   catch (Standard_Failure) {
2603     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2604     SetErrorCode(aFail->GetMessageString());
2605     return NULL;
2606   }
2607
2608   //Make a Python command
2609   TCollection_AsciiString anEntry, aDescr;
2610   TDF_Tool::Entry(aCopy->GetEntry(), anEntry);
2611   aDescr += anEntry + " = IBlocksOperations.MakeMultiTransformation1D(";
2612   TDF_Tool::Entry(theObject->GetEntry(), anEntry);
2613   aDescr += anEntry + ", ";
2614   aDescr += TCollection_AsciiString(theDirFace1) + ", ";
2615   aDescr += TCollection_AsciiString(theDirFace2) + ", ";
2616   aDescr += TCollection_AsciiString(theNbTimes)  + ") ";
2617
2618   aFunction->SetDescription(aDescr);
2619
2620   SetErrorCode(OK);
2621   return aCopy;
2622 }
2623
2624 //=============================================================================
2625 /*!
2626  *  MakeMultiTransformation2D
2627  */
2628 //=============================================================================
2629 Handle(GEOM_Object) GEOMImpl_IBlocksOperations::MakeMultiTransformation2D
2630                                              (Handle(GEOM_Object)    theObject,
2631                                               const Standard_Integer theDirFace1U,
2632                                               const Standard_Integer theDirFace2U,
2633                                               const Standard_Integer theNbTimesU,
2634                                               const Standard_Integer theDirFace1V,
2635                                               const Standard_Integer theDirFace2V,
2636                                               const Standard_Integer theNbTimesV)
2637 {
2638   SetErrorCode(KO);
2639
2640   if (theObject.IsNull()) return NULL;
2641
2642   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
2643   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
2644
2645   //Add a new Copy object
2646   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
2647
2648   //Add a translate function
2649   Handle(GEOM_Function) aFunction =
2650     aCopy->AddFunction(GEOMImpl_BlockDriver::GetID(), BLOCK_MULTI_TRANSFORM_2D);
2651
2652   //Check if the function is set correctly
2653   if (aFunction->GetDriverGUID() != GEOMImpl_BlockDriver::GetID()) return NULL;
2654
2655   GEOMImpl_IBlockTrsf aTI (aFunction);
2656   aTI.SetOriginal(aLastFunction);
2657   aTI.SetFace1U(theDirFace1U);
2658   aTI.SetFace2U(theDirFace2U);
2659   aTI.SetNbIterU(theNbTimesU);
2660   aTI.SetFace1V(theDirFace1V);
2661   aTI.SetFace2V(theDirFace2V);
2662   aTI.SetNbIterV(theNbTimesV);
2663
2664   //Compute the transformation
2665   try {
2666     if (!GetSolver()->ComputeFunction(aFunction)) {
2667       SetErrorCode("Block driver failed to make multi-transformation");
2668       return NULL;
2669     }
2670   }
2671   catch (Standard_Failure) {
2672     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2673     SetErrorCode(aFail->GetMessageString());
2674     return NULL;
2675   }
2676
2677   //Make a Python command
2678   TCollection_AsciiString anEntry, aDescr;
2679   TDF_Tool::Entry(aCopy->GetEntry(), anEntry);
2680   aDescr += anEntry + " = IBlocksOperations.MakeMultiTransformation2D(";
2681   TDF_Tool::Entry(theObject->GetEntry(), anEntry);
2682   aDescr += anEntry + ", ";
2683   aDescr += TCollection_AsciiString(theDirFace1U) + ", ";
2684   aDescr += TCollection_AsciiString(theDirFace2U) + ", ";
2685   aDescr += TCollection_AsciiString(theNbTimesU)  + ", ";
2686   aDescr += TCollection_AsciiString(theDirFace1V) + ", ";
2687   aDescr += TCollection_AsciiString(theDirFace2V) + ", ";
2688   aDescr += TCollection_AsciiString(theNbTimesV)  + ") ";
2689
2690   aFunction->SetDescription(aDescr);
2691
2692   SetErrorCode(OK);
2693   return aCopy;
2694 }