src/GEOM_I/GEOM_IBlocksOperations_i.cc

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #include <Standard_Stream.hxx>
  24
  25 #include "GEOM_IBlocksOperations_i.hh"
  26
  27 #include "utilities.h"
  28 #include "OpUtil.hxx"
  29 #include "Utils_ExceptHandlers.hxx"
  30
  31 #include "GEOM_Engine.hxx"
  32 #include "GEOM_Object.hxx"
  33
  34 #include <TColStd_HSequenceOfTransient.hxx>
  35 #include <TColStd_HArray1OfInteger.hxx>
  36
  37 //=============================================================================
  38 /*!
  39  *   constructor:
  40  */
  41 //=============================================================================
  42 GEOM_IBlocksOperations_i::GEOM_IBlocksOperations_i (PortableServer::POA_ptr thePOA,
  43                                                     GEOM::GEOM_Gen_ptr theEngine,
  44                                                     ::GEOMImpl_IBlocksOperations* theImpl)
  45 :GEOM_IOperations_i(thePOA, theEngine, theImpl)
  46 {
  47   MESSAGE("GEOM_IBlocksOperations_i::GEOM_IBlocksOperations_i");
  48 }
  49
  50 //=============================================================================
  51 /*!
  52  *  destructor
  53  */
  54 //=============================================================================
  55 GEOM_IBlocksOperations_i::~GEOM_IBlocksOperations_i()
  56 {
  57   MESSAGE("GEOM_IBlocksOperations_i::~GEOM_IBlocksOperations_i");
  58 }
  59
  60
  61 //=============================================================================
  62 /*!
  63  *  MakeQuad
  64  */
  65 //=============================================================================
  66 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeQuad
  67                (GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2,
  68                 GEOM::GEOM_Object_ptr theEdge3, GEOM::GEOM_Object_ptr theEdge4)
  69 {
  70   GEOM::GEOM_Object_var aGEOMObject;
  71
  72   //Set a not done flag
  73   GetOperations()->SetNotDone();
  74
  75   //Get the reference edges
  76   Handle(GEOM_Object) anEdge1 = GetObjectImpl(theEdge1);
  77   Handle(GEOM_Object) anEdge2 = GetObjectImpl(theEdge2);
  78   Handle(GEOM_Object) anEdge3 = GetObjectImpl(theEdge3);
  79   Handle(GEOM_Object) anEdge4 = GetObjectImpl(theEdge4);
  80
  81   if (anEdge1.IsNull() || anEdge2.IsNull() ||
  82       anEdge3.IsNull() || anEdge4.IsNull()) return aGEOMObject._retn();
  83
  84   //Create the Face
  85   Handle(GEOM_Object) anObject =
  86     GetOperations()->MakeQuad(anEdge1, anEdge2, anEdge3, anEdge4);
  87   if (!GetOperations()->IsDone() || anObject.IsNull())
  88     return aGEOMObject._retn();
  89
  90   return GetObject(anObject);
  91 }
  92
  93 //=============================================================================
  94 /*!
  95  *  MakeQuad2Edges
  96  */
  97 //=============================================================================
  98 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeQuad2Edges
  99                (GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2)
 100 {
 101   GEOM::GEOM_Object_var aGEOMObject;
 102
 103   //Set a not done flag
 104   GetOperations()->SetNotDone();
 105
 106   //Get the reference edges
 107   Handle(GEOM_Object) anEdge1 = GetObjectImpl(theEdge1);
 108   Handle(GEOM_Object) anEdge2 = GetObjectImpl(theEdge2);
 109
 110   if (anEdge1.IsNull() || anEdge2.IsNull()) return aGEOMObject._retn();
 111
 112   //Create the Face
 113   Handle(GEOM_Object) anObject =
 114     GetOperations()->MakeQuad2Edges(anEdge1, anEdge2);
 115   if (!GetOperations()->IsDone() || anObject.IsNull())
 116     return aGEOMObject._retn();
 117
 118   return GetObject(anObject);
 119 }
 120
 121 //=============================================================================
 122 /*!
 123  *  MakeQuad4Vertices
 124  */
 125 //=============================================================================
 126 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeQuad4Vertices
 127                       (GEOM::GEOM_Object_ptr thePnt1, GEOM::GEOM_Object_ptr thePnt2,
 128                        GEOM::GEOM_Object_ptr thePnt3, GEOM::GEOM_Object_ptr thePnt4)
 129 {
 130   GEOM::GEOM_Object_var aGEOMObject;
 131
 132   //Set a not done flag
 133   GetOperations()->SetNotDone();
 134
 135   //Get the reference points
 136   Handle(GEOM_Object) aPnt1 = GetObjectImpl(thePnt1);
 137   Handle(GEOM_Object) aPnt2 = GetObjectImpl(thePnt2);
 138   Handle(GEOM_Object) aPnt3 = GetObjectImpl(thePnt3);
 139   Handle(GEOM_Object) aPnt4 = GetObjectImpl(thePnt4);
 140
 141   if (aPnt1.IsNull() || aPnt2.IsNull() ||
 142       aPnt3.IsNull() || aPnt4.IsNull()) return aGEOMObject._retn();
 143
 144   //Create the Face
 145   Handle(GEOM_Object) anObject =
 146     GetOperations()->MakeQuad4Vertices(aPnt1, aPnt2, aPnt3, aPnt4);
 147   if (!GetOperations()->IsDone() || anObject.IsNull())
 148     return aGEOMObject._retn();
 149
 150   return GetObject(anObject);
 151 }
 152
 153 //=============================================================================
 154 /*!
 155  *  MakeHexa
 156  */
 157 //=============================================================================
 158 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeHexa
 159                (GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2,
 160                 GEOM::GEOM_Object_ptr theFace3, GEOM::GEOM_Object_ptr theFace4,
 161                 GEOM::GEOM_Object_ptr theFace5, GEOM::GEOM_Object_ptr theFace6)
 162 {
 163   GEOM::GEOM_Object_var aGEOMObject;
 164
 165   //Set a not done flag
 166   GetOperations()->SetNotDone();
 167
 168   //Get the reference Faces
 169   Handle(GEOM_Object) anFace1 = GetObjectImpl(theFace1);
 170   Handle(GEOM_Object) anFace2 = GetObjectImpl(theFace2);
 171   Handle(GEOM_Object) anFace3 = GetObjectImpl(theFace3);
 172   Handle(GEOM_Object) anFace4 = GetObjectImpl(theFace4);
 173   Handle(GEOM_Object) anFace5 = GetObjectImpl(theFace5);
 174   Handle(GEOM_Object) anFace6 = GetObjectImpl(theFace6);
 175
 176   if (anFace1.IsNull() || anFace2.IsNull() ||
 177       anFace3.IsNull() || anFace4.IsNull() ||
 178       anFace5.IsNull() || anFace6.IsNull()) return aGEOMObject._retn();
 179
 180   //Create the Face
 181   Handle(GEOM_Object) anObject = GetOperations()->MakeHexa
 182     (anFace1, anFace2, anFace3, anFace4, anFace5, anFace6);
 183   if (!GetOperations()->IsDone() || anObject.IsNull())
 184     return aGEOMObject._retn();
 185
 186   return GetObject(anObject);
 187 }
 188
 189 //=============================================================================
 190 /*!
 191  *  MakeHexa2Faces
 192  */
 193 //=============================================================================
 194 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeHexa2Faces
 195                (GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2)
 196 {
 197   GEOM::GEOM_Object_var aGEOMObject;
 198
 199   //Set a not done flag
 200   GetOperations()->SetNotDone();
 201
 202   //Get the reference Faces
 203   Handle(GEOM_Object) anFace1 = GetObjectImpl(theFace1);
 204   Handle(GEOM_Object) anFace2 = GetObjectImpl(theFace2);
 205
 206   if (anFace1.IsNull() || anFace2.IsNull()) return aGEOMObject._retn();
 207
 208   //Create the Face
 209   Handle(GEOM_Object) anObject =
 210     GetOperations()->MakeHexa2Faces(anFace1, anFace2);
 211   if (!GetOperations()->IsDone() || anObject.IsNull())
 212     return aGEOMObject._retn();
 213
 214   return GetObject(anObject);
 215 }
 216
 217 //=============================================================================
 218 /*!
 219  *  MakeBlockCompound
 220  */
 221 //=============================================================================
 222 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeBlockCompound
 223                                             (GEOM::GEOM_Object_ptr theCompound)
 224 {
 225   GEOM::GEOM_Object_var aGEOMObject;
 226
 227   //Set a not done flag
 228   GetOperations()->SetNotDone();
 229
 230   //Get the reference Compound
 231   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 232   if (aCompound.IsNull()) return aGEOMObject._retn();
 233
 234   //Create the Blocks Compound
 235   Handle(GEOM_Object) anObject =
 236     GetOperations()->MakeBlockCompound(aCompound);
 237   if (!GetOperations()->IsDone() || anObject.IsNull())
 238     return aGEOMObject._retn();
 239
 240   return GetObject(anObject);
 241 }
 242
 243 //=============================================================================
 244 /*!
 245  *  GetPoint
 246  */
 247 //=============================================================================
 248 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetPoint (GEOM::GEOM_Object_ptr theShape,
 249                                                           const CORBA::Double   theX,
 250                                                           const CORBA::Double   theY,
 251                                                           const CORBA::Double   theZ,
 252                                                           const CORBA::Double   theEpsilon)
 253 {
 254   GEOM::GEOM_Object_var aGEOMObject;
 255
 256   //Set a not done flag
 257   GetOperations()->SetNotDone();
 258
 259   //Get the reference Objects
 260   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 261   if (aShape.IsNull()) return aGEOMObject._retn();
 262
 263   //Create the Point
 264   Handle(GEOM_Object) anObject =
 265     GetOperations()->GetPoint(aShape, theX, theY, theZ, theEpsilon);
 266   if (!GetOperations()->IsDone() || anObject.IsNull())
 267     return aGEOMObject._retn();
 268
 269   return GetObject(anObject);
 270 }
 271
 272 //=============================================================================
 273 /*!
 274  *  GetVertexNearPoint
 275  */
 276 //=============================================================================
 277 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetVertexNearPoint
 278                                                 (GEOM::GEOM_Object_ptr theShape,
 279                                                  GEOM::GEOM_Object_ptr thePoint)
 280 {
 281   GEOM::GEOM_Object_var aGEOMObject;
 282
 283   // Set a not done flag
 284   GetOperations()->SetNotDone();
 285
 286   // Get the reference Objects
 287   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 288   Handle(GEOM_Object) aPoint = GetObjectImpl(thePoint);
 289   if (aShape.IsNull() || aPoint.IsNull()) return aGEOMObject._retn();
 290
 291   // Create the Point
 292   Handle(GEOM_Object) anObject =
 293     GetOperations()->GetVertexNearPoint(aShape, aPoint);
 294   if (!GetOperations()->IsDone() || anObject.IsNull())
 295     return aGEOMObject._retn();
 296
 297   return GetObject(anObject);
 298 }
 299
 300 //=============================================================================
 301 /*!
 302  *  GetEdge
 303  */
 304 //=============================================================================
 305 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetEdge (GEOM::GEOM_Object_ptr theShape,
 306                                                          GEOM::GEOM_Object_ptr thePoint1,
 307                                                          GEOM::GEOM_Object_ptr thePoint2)
 308 {
 309   GEOM::GEOM_Object_var aGEOMObject;
 310
 311   //Set a not done flag
 312   GetOperations()->SetNotDone();
 313
 314   //Get the reference Objects
 315   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 316   Handle(GEOM_Object) aPoint1 = GetObjectImpl(thePoint1);
 317   Handle(GEOM_Object) aPoint2 = GetObjectImpl(thePoint2);
 318
 319   if (aShape.IsNull() ||
 320       aPoint1.IsNull() || aPoint2.IsNull()) return aGEOMObject._retn();
 321
 322   //Create the Point
 323   Handle(GEOM_Object) anObject =
 324     GetOperations()->GetEdge(aShape, aPoint1, aPoint2);
 325   if (!GetOperations()->IsDone() || anObject.IsNull())
 326     return aGEOMObject._retn();
 327
 328   return GetObject(anObject);
 329 }
 330
 331 //=============================================================================
 332 /*!
 333  *  GetEdgeNearPoint
 334  */
 335 //=============================================================================
 336 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetEdgeNearPoint (GEOM::GEOM_Object_ptr theShape,
 337                                                                   GEOM::GEOM_Object_ptr thePoint)
 338 {
 339   GEOM::GEOM_Object_var aGEOMObject;
 340
 341   //Set a not done flag
 342   GetOperations()->SetNotDone();
 343
 344   //Get the reference Objects
 345   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 346   Handle(GEOM_Object) aPoint = GetObjectImpl(thePoint);
 347
 348   if (aShape.IsNull() || aPoint.IsNull()) return aGEOMObject._retn();
 349
 350   //Create the Edge
 351   Handle(GEOM_Object) anObject =
 352     GetOperations()->GetEdgeNearPoint(aShape, aPoint);
 353   if (!GetOperations()->IsDone() || anObject.IsNull())
 354     return aGEOMObject._retn();
 355
 356   return GetObject(anObject);
 357 }
 358
 359 //=============================================================================
 360 /*!
 361  *  GetFaceByPoints
 362  */
 363 //=============================================================================
 364 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetFaceByPoints
 365                                               (GEOM::GEOM_Object_ptr theShape,
 366                                                GEOM::GEOM_Object_ptr thePoint1,
 367                                                GEOM::GEOM_Object_ptr thePoint2,
 368                                                GEOM::GEOM_Object_ptr thePoint3,
 369                                                GEOM::GEOM_Object_ptr thePoint4)
 370 {
 371   GEOM::GEOM_Object_var aGEOMObject;
 372
 373   //Set a not done flag
 374   GetOperations()->SetNotDone();
 375
 376   //Get the reference Objects
 377   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 378   Handle(GEOM_Object) aPoint1 = GetObjectImpl(thePoint1);
 379   Handle(GEOM_Object) aPoint2 = GetObjectImpl(thePoint2);
 380   Handle(GEOM_Object) aPoint3 = GetObjectImpl(thePoint3);
 381   Handle(GEOM_Object) aPoint4 = GetObjectImpl(thePoint4);
 382
 383   if (aShape.IsNull() ||
 384       aPoint1.IsNull() || aPoint2.IsNull() ||
 385       aPoint3.IsNull() || aPoint4.IsNull()) return aGEOMObject._retn();
 386
 387   //Create the Face
 388   Handle(GEOM_Object) anObject =
 389     GetOperations()->GetFaceByPoints(aShape, aPoint1, aPoint2, aPoint3, aPoint4);
 390   if (!GetOperations()->IsDone() || anObject.IsNull())
 391     return aGEOMObject._retn();
 392
 393   return GetObject(anObject);
 394 }
 395
 396 //=============================================================================
 397 /*!
 398  *  GetFaceByEdges
 399  */
 400 //=============================================================================
 401 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetFaceByEdges
 402                                                (GEOM::GEOM_Object_ptr theShape,
 403                                                 GEOM::GEOM_Object_ptr theEdge1,
 404                                                 GEOM::GEOM_Object_ptr theEdge2)
 405 {
 406   GEOM::GEOM_Object_var aGEOMObject;
 407
 408   //Set a not done flag
 409   GetOperations()->SetNotDone();
 410
 411   //Get the reference Objects
 412   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 413   Handle(GEOM_Object) anEdge1 = GetObjectImpl(theEdge1);
 414   Handle(GEOM_Object) anEdge2 = GetObjectImpl(theEdge2);
 415
 416   if (aShape.IsNull() ||
 417       anEdge1.IsNull() || anEdge2.IsNull()) return aGEOMObject._retn();
 418
 419   //Create the Face
 420   Handle(GEOM_Object) anObject =
 421     GetOperations()->GetFaceByEdges(aShape, anEdge1, anEdge2);
 422   if (!GetOperations()->IsDone() || anObject.IsNull())
 423     return aGEOMObject._retn();
 424
 425   return GetObject(anObject);
 426 }
 427
 428 //=============================================================================
 429 /*!
 430  *  GetOppositeFace
 431  */
 432 //=============================================================================
 433 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetOppositeFace (GEOM::GEOM_Object_ptr theShape,
 434                                                                  GEOM::GEOM_Object_ptr theFace)
 435 {
 436   GEOM::GEOM_Object_var aGEOMObject;
 437
 438   //Set a not done flag
 439   GetOperations()->SetNotDone();
 440
 441   //Get the reference Objects
 442   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 443   Handle(GEOM_Object) aFace = GetObjectImpl(theFace);
 444
 445   if (aShape.IsNull() || aFace.IsNull()) return aGEOMObject._retn();
 446
 447   //Create the Face
 448   Handle(GEOM_Object) anObject =
 449     GetOperations()->GetOppositeFace(aShape, aFace);
 450   if (!GetOperations()->IsDone() || anObject.IsNull())
 451     return aGEOMObject._retn();
 452
 453   return GetObject(anObject);
 454 }
 455
 456 //=============================================================================
 457 /*!
 458  *  GetFaceNearPoint
 459  */
 460 //=============================================================================
 461 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetFaceNearPoint (GEOM::GEOM_Object_ptr theShape,
 462                                                                   GEOM::GEOM_Object_ptr thePoint)
 463 {
 464   GEOM::GEOM_Object_var aGEOMObject;
 465
 466   //Set a not done flag
 467   GetOperations()->SetNotDone();
 468
 469   //Get the reference Objects
 470   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 471   Handle(GEOM_Object) aPoint = GetObjectImpl(thePoint);
 472
 473   if (aShape.IsNull() || aPoint.IsNull()) return aGEOMObject._retn();
 474
 475   //Create the Face
 476   Handle(GEOM_Object) anObject =
 477     GetOperations()->GetFaceNearPoint(aShape, aPoint);
 478   if (!GetOperations()->IsDone() || anObject.IsNull())
 479     return aGEOMObject._retn();
 480
 481   return GetObject(anObject);
 482 }
 483
 484 //=============================================================================
 485 /*!
 486  *  GetFaceByNormale
 487  */
 488 //=============================================================================
 489 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetFaceByNormale (GEOM::GEOM_Object_ptr theShape,
 490                                                                   GEOM::GEOM_Object_ptr theVector)
 491 {
 492   GEOM::GEOM_Object_var aGEOMObject;
 493
 494   //Set a not done flag
 495   GetOperations()->SetNotDone();
 496
 497   //Get the reference Objects
 498   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 499   Handle(GEOM_Object) aVector = GetObjectImpl(theVector);
 500
 501   if (aShape.IsNull() || aVector.IsNull()) return aGEOMObject._retn();
 502
 503   //Create the Face
 504   Handle(GEOM_Object) anObject =
 505     GetOperations()->GetFaceByNormale(aShape, aVector);
 506   if (!GetOperations()->IsDone() || anObject.IsNull())
 507     return aGEOMObject._retn();
 508
 509   return GetObject(anObject);
 510 }
 511
 512 //=============================================================================
 513 /*!
 514  *  GetShapesNearPoint
 515  */
 516 //=============================================================================
 517 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetShapesNearPoint
 518                       (GEOM::GEOM_Object_ptr theShape,
 519                        GEOM::GEOM_Object_ptr thePoint,
 520                        CORBA::Long           theShapeType,
 521                        CORBA::Double         theTolerance)
 522 {
 523   GEOM::GEOM_Object_var aGEOMObject;
 524
 525   // Set a not done flag
 526   GetOperations()->SetNotDone();
 527
 528   // Get the reference Objects
 529   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 530   Handle(GEOM_Object) aPoint = GetObjectImpl(thePoint);
 531
 532   if (aShape.IsNull() || aPoint.IsNull()) return aGEOMObject._retn();
 533
 534   // Create the Shape
 535   Handle(GEOM_Object) anObject =
 536     GetOperations()->GetShapesNearPoint(aShape, aPoint, theShapeType, theTolerance);
 537   if (!GetOperations()->IsDone() || anObject.IsNull())
 538     return aGEOMObject._retn();
 539
 540   return GetObject(anObject);
 541 }
 542
 543 //=============================================================================
 544 /*!
 545  *  ExplodeCompoundOfBlocks
 546  */
 547 //=============================================================================
 548 GEOM::ListOfGO* GEOM_IBlocksOperations_i::ExplodeCompoundOfBlocks
 549                                           (GEOM::GEOM_Object_ptr theCompound,
 550                                            const CORBA::Long     theMinNbFaces,
 551                                            const CORBA::Long     theMaxNbFaces)
 552 {
 553   GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
 554
 555   //Set a not done flag
 556   GetOperations()->SetNotDone();
 557
 558   //Get the reference Compound
 559   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 560   if (aCompound.IsNull()) return aSeq._retn();
 561
 562   //Explode
 563   Handle(TColStd_HSequenceOfTransient) aHSeq =
 564     GetOperations()->ExplodeCompoundOfBlocks(aCompound, theMinNbFaces, theMaxNbFaces);
 565   if (!GetOperations()->IsDone() || aHSeq.IsNull())
 566     return aSeq._retn();
 567
 568   Standard_Integer aLength = aHSeq->Length();
 569   aSeq->length(aLength);
 570   for (Standard_Integer i = 1; i <= aLength; i++)
 571     aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
 572
 573   return aSeq._retn();
 574 }
 575
 576 //=============================================================================
 577 /*!
 578  *  IsCompoundOfBlocks
 579  */
 580 //=============================================================================
 581 CORBA::Boolean GEOM_IBlocksOperations_i::IsCompoundOfBlocks
 582                                           (GEOM::GEOM_Object_ptr theCompound,
 583                                            const CORBA::Long     theMinNbFaces,
 584                                            const CORBA::Long     theMaxNbFaces,
 585                                            CORBA::Long&          theNbBlocks)
 586 {
 587   theNbBlocks = 0;
 588   CORBA::Boolean isComp = false;
 589
 590   //Set a not done flag
 591   GetOperations()->SetNotDone();
 592
 593   //Get the reference Compound
 594   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 595   if (aCompound.IsNull()) return isComp;
 596
 597   //Check
 598   Standard_Integer nbBlocks = 0;
 599   isComp = GetOperations()->IsCompoundOfBlocks(aCompound,
 600                                                theMinNbFaces,
 601                                                theMaxNbFaces,
 602                                                nbBlocks);
 603   if (!GetOperations()->IsDone())
 604     return isComp;
 605
 606   theNbBlocks = nbBlocks;
 607   return isComp;
 608 }
 609
 610 //=============================================================================
 611 /*!
 612  *  CheckCompoundOfBlocks
 613  */
 614 //=============================================================================
 615 CORBA::Boolean GEOM_IBlocksOperations_i::CheckCompoundOfBlocks
 616                                           (GEOM::GEOM_Object_ptr theCompound,
 617                                            const CORBA::Double   theToleranceC1,
 618                                            GEOM::GEOM_IBlocksOperations::BCErrors_out theErrors)
 619 {
 620   CORBA::Boolean isComp = false;
 621
 622   //Set a not done flag
 623   GetOperations()->SetNotDone();
 624
 625   //Get the reference Compound
 626   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 627   if (aCompound.IsNull()) return isComp;
 628
 629   //Check
 630   std::list<GEOMImpl_IBlocksOperations::BCError> errList;
 631   isComp = GetOperations()->CheckCompoundOfBlocks
 632     (aCompound, theToleranceC1, errList);
 633   if (!GetOperations()->IsDone())
 634     return isComp;
 635
 636   const int nbErr = errList.size();
 637   GEOM::GEOM_IBlocksOperations::BCErrors_var anErrArray =
 638     new GEOM::GEOM_IBlocksOperations::BCErrors();
 639   anErrArray->length(nbErr);
 640
 641   // fill the local CORBA array with values from lists
 642   std::list<GEOMImpl_IBlocksOperations::BCError>::iterator errIt = errList.begin();
 643   int i = 0;
 644   for (; errIt != errList.end(); i++, errIt++) {
 645     GEOM::GEOM_IBlocksOperations::BCError_var anError =
 646       new GEOM::GEOM_IBlocksOperations::BCError();
 647
 648     GEOMImpl_IBlocksOperations::BCError errStruct = *errIt;
 649
 650     switch (errStruct.error) {
 651     case GEOMImpl_IBlocksOperations::NOT_BLOCK:
 652       anError->error = GEOM::GEOM_IBlocksOperations::NOT_BLOCK;
 653       break;
 654     case GEOMImpl_IBlocksOperations::EXTRA_EDGE:
 655       anError->error = GEOM::GEOM_IBlocksOperations::EXTRA_EDGE;
 656       break;
 657     case GEOMImpl_IBlocksOperations::INVALID_CONNECTION:
 658       anError->error = GEOM::GEOM_IBlocksOperations::INVALID_CONNECTION;
 659       break;
 660     case GEOMImpl_IBlocksOperations::NOT_CONNECTED:
 661       anError->error = GEOM::GEOM_IBlocksOperations::NOT_CONNECTED;
 662       break;
 663     case GEOMImpl_IBlocksOperations::NOT_GLUED:
 664       anError->error = GEOM::GEOM_IBlocksOperations::NOT_GLUED;
 665       break;
 666     default:
 667       break;
 668     }
 669
 670     std::list<int> sshList = errStruct.incriminated;
 671     GEOM::ListOfLong_var anIncrims = new GEOM::ListOfLong();
 672     anIncrims->length(sshList.size());
 673
 674     std::list<int>::iterator sshIt = sshList.begin();
 675     int jj = 0;
 676     for (; sshIt != sshList.end(); jj++, sshIt++) {
 677       anIncrims[jj] = *sshIt;
 678     }
 679
 680     anError->incriminated = anIncrims;
 681
 682     anErrArray[i] = anError;
 683   }
 684
 685   // initialize out-parameter with local array
 686   theErrors = anErrArray._retn();
 687
 688   return isComp;
 689 }
 690
 691 //=============================================================================
 692 /*!
 693  *  PrintBCErrors
 694  */
 695 //=============================================================================
 696 char* GEOM_IBlocksOperations_i::PrintBCErrors
 697                       (GEOM::GEOM_Object_ptr theCompound,
 698                        const GEOM::GEOM_IBlocksOperations::BCErrors& theErrors)
 699 {
 700   //Get the reference Compound
 701   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 702   if (aCompound.IsNull()) return NULL;
 703
 704   // Convert the errors sequence
 705   std::list<GEOMImpl_IBlocksOperations::BCError> anErrors;
 706   int nbErr = theErrors.length();
 707   int ie = 0;
 708   for (; ie < nbErr; ie++) {
 709     const GEOM::GEOM_IBlocksOperations::BCError err = theErrors[ie];
 710     const GEOM::GEOM_IBlocksOperations::BCErrorType typ = err.error;
 711     const GEOM::ListOfLong incrims = err.incriminated;
 712
 713     GEOMImpl_IBlocksOperations::BCError errStruct;
 714     switch (typ) {
 715     case GEOM::GEOM_IBlocksOperations::NOT_BLOCK:
 716       errStruct.error = GEOMImpl_IBlocksOperations::NOT_BLOCK;
 717       break;
 718     case GEOM::GEOM_IBlocksOperations::EXTRA_EDGE:
 719       errStruct.error = GEOMImpl_IBlocksOperations::EXTRA_EDGE;
 720       break;
 721     case GEOM::GEOM_IBlocksOperations::INVALID_CONNECTION:
 722       errStruct.error = GEOMImpl_IBlocksOperations::INVALID_CONNECTION;
 723       break;
 724     case GEOM::GEOM_IBlocksOperations::NOT_CONNECTED:
 725       errStruct.error = GEOMImpl_IBlocksOperations::NOT_CONNECTED;
 726       break;
 727     case GEOM::GEOM_IBlocksOperations::NOT_GLUED:
 728       errStruct.error = GEOMImpl_IBlocksOperations::NOT_GLUED;
 729       break;
 730     default:
 731       break;
 732     }
 733
 734     int ii = 0;
 735     int aLen = incrims.length();
 736     for (; ii < aLen; ii++) {
 737       errStruct.incriminated.push_back(incrims[ii]);
 738     }
 739
 740     anErrors.push_back(errStruct);
 741   }
 742
 743   TCollection_AsciiString aDescr = GetOperations()->PrintBCErrors(aCompound, anErrors);
 744   return CORBA::string_dup(aDescr.ToCString());
 745 }
 746
 747 //=============================================================================
 748 /*!
 749  *  GetNonBlocks
 750  */
 751 //=============================================================================
 752 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetNonBlocks
 753                                       (GEOM::GEOM_Object_ptr theShape,
 754                                        const CORBA::Double   theToleranceC1,
 755                                        GEOM::GEOM_Object_out theNonQuads)
 756 {
 757   GEOM::GEOM_Object_var aGEOMObject;
 758   GEOM::GEOM_Object_var aNonQuads;
 759
 760   theNonQuads = aNonQuads._retn();
 761
 762   //Set a not done flag
 763   GetOperations()->SetNotDone();
 764
 765   //Get the reference Objects
 766   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 767   if (aShape.IsNull()) return aGEOMObject._retn();
 768
 769   //Get the result
 770   Handle(GEOM_Object) aFaces;
 771   Handle(GEOM_Object) anObject =
 772     GetOperations()->GetNonBlocks(aShape, theToleranceC1, aFaces);
 773   if (!GetOperations()->IsDone())
 774     return aGEOMObject._retn();
 775
 776   if (!aFaces.IsNull())
 777     theNonQuads = GetObject(aFaces);
 778
 779   if (anObject.IsNull())
 780     return aGEOMObject._retn();
 781
 782   return GetObject(anObject);
 783 }
 784
 785 //=============================================================================
 786 /*!
 787  *  RemoveExtraEdges
 788  */
 789 //=============================================================================
 790 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::RemoveExtraEdges
 791                                       (GEOM::GEOM_Object_ptr theShape,
 792                                        CORBA::Long           theOptimumNbFaces)
 793 {
 794   GEOM::GEOM_Object_var aGEOMObject;
 795
 796   //Set a not done flag
 797   GetOperations()->SetNotDone();
 798
 799   //Get the reference Objects
 800   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 801   if (aShape.IsNull()) return aGEOMObject._retn();
 802
 803   //Get the result
 804   Handle(GEOM_Object) anObject = GetOperations()->RemoveExtraEdges(aShape, theOptimumNbFaces);
 805   if (!GetOperations()->IsDone() || anObject.IsNull())
 806     return aGEOMObject._retn();
 807
 808   return GetObject(anObject);
 809 }
 810
 811 //=============================================================================
 812 /*!
 813  *  UnionFaces
 814  */
 815 //=============================================================================
 816 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::UnionFaces
 817                                       (GEOM::GEOM_Object_ptr theShape)
 818 {
 819   GEOM::GEOM_Object_var aGEOMObject;
 820
 821   //Set a not done flag
 822   GetOperations()->SetNotDone();
 823
 824   //Get the reference Objects
 825   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 826   if (aShape.IsNull()) return aGEOMObject._retn();
 827
 828   //Get the result
 829   Handle(GEOM_Object) anObject = GetOperations()->UnionFaces(aShape);
 830   if (!GetOperations()->IsDone() || anObject.IsNull())
 831     return aGEOMObject._retn();
 832
 833   return GetObject(anObject);
 834 }
 835
 836 //=============================================================================
 837 /*!
 838  *  CheckAndImprove
 839  */
 840 //=============================================================================
 841 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::CheckAndImprove (GEOM::GEOM_Object_ptr theCompound)
 842 {
 843   GEOM::GEOM_Object_var aGEOMObject;
 844
 845   //Set a not done flag
 846   GetOperations()->SetNotDone();
 847
 848   //Get the reference Objects
 849   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 850   if (aCompound.IsNull()) return aGEOMObject._retn();
 851
 852   //Get the result
 853   Handle(GEOM_Object) anObject =
 854     GetOperations()->CheckAndImprove(aCompound);
 855   if (!GetOperations()->IsDone() || anObject.IsNull())
 856     return aGEOMObject._retn();
 857
 858   return GetObject(anObject);
 859 }
 860
 861 //=============================================================================
 862 /*!
 863  *  GetBlockNearPoint
 864  */
 865 //=============================================================================
 866 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetBlockNearPoint (GEOM::GEOM_Object_ptr theCompound,
 867                                                                    GEOM::GEOM_Object_ptr thePoint)
 868 {
 869   GEOM::GEOM_Object_var aGEOMObject;
 870
 871   //Set a not done flag
 872   GetOperations()->SetNotDone();
 873
 874   //Get the reference Objects
 875   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 876   Handle(GEOM_Object) aPoint = GetObjectImpl(thePoint);
 877
 878   if (aCompound.IsNull() || aPoint.IsNull()) return aGEOMObject._retn();
 879
 880   //Get the block
 881   Handle(GEOM_Object) anObject =
 882     GetOperations()->GetBlockNearPoint(aCompound, aPoint);
 883   if (!GetOperations()->IsDone() || anObject.IsNull())
 884     return aGEOMObject._retn();
 885
 886   return GetObject(anObject);
 887 }
 888
 889 //=============================================================================
 890 /*!
 891  *  GetBlockByParts
 892  */
 893 //=============================================================================
 894 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetBlockByParts (GEOM::GEOM_Object_ptr theCompound,
 895                                                                  const GEOM::ListOfGO& theParts)
 896 {
 897   GEOM::GEOM_Object_var aGEOMObject;
 898
 899   //Set a not done flag
 900   GetOperations()->SetNotDone();
 901
 902   //Get the reference Compound
 903   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 904   if (aCompound.IsNull()) return aGEOMObject._retn();
 905
 906   //Get the parts
 907   int ind, aLen;
 908   Handle(TColStd_HSequenceOfTransient) aParts = new TColStd_HSequenceOfTransient;
 909
 910   aLen = theParts.length();
 911   for (ind = 0; ind < aLen; ind++) {
 912     Handle(GEOM_Object) aSh = GetObjectImpl(theParts[ind]);
 913     if (aSh.IsNull()) return aGEOMObject._retn();
 914     aParts->Append(aSh);
 915   }
 916
 917   //Get the Block
 918   Handle(GEOM_Object) anObject =
 919     GetOperations()->GetBlockByParts(aCompound, aParts);
 920   if (!GetOperations()->IsDone() || anObject.IsNull())
 921     return aGEOMObject._retn();
 922
 923   return GetObject(anObject);
 924 }
 925
 926 //=============================================================================
 927 /*!
 928  *  GetBlocksByParts
 929  */
 930 //=============================================================================
 931 GEOM::ListOfGO* GEOM_IBlocksOperations_i::GetBlocksByParts (GEOM::GEOM_Object_ptr theCompound,
 932                                                             const GEOM::ListOfGO& theParts)
 933 {
 934   GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
 935
 936   //Set a not done flag
 937   GetOperations()->SetNotDone();
 938
 939   //Get the reference Compound
 940   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 941   if (aCompound.IsNull()) return aSeq._retn();
 942
 943   //Get the parts
 944   int ind, aLen;
 945   Handle(TColStd_HSequenceOfTransient) aParts = new TColStd_HSequenceOfTransient;
 946
 947   aLen = theParts.length();
 948   for (ind = 0; ind < aLen; ind++) {
 949     Handle(GEOM_Object) aSh = GetObjectImpl(theParts[ind]);
 950     if (aSh.IsNull()) return aSeq._retn();
 951     aParts->Append(aSh);
 952   }
 953
 954   //Get the Block
 955   Handle(TColStd_HSequenceOfTransient) aHSeq =
 956     GetOperations()->GetBlocksByParts(aCompound, aParts);
 957   if (!GetOperations()->IsDone() || aHSeq.IsNull())
 958     return aSeq._retn();
 959
 960   Standard_Integer aLength = aHSeq->Length();
 961   aSeq->length(aLength);
 962   for (Standard_Integer i = 1; i <= aLength; i++)
 963     aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
 964
 965   return aSeq._retn();
 966 }
 967
 968 //=============================================================================
 969 /*!
 970  *  MakeMultiTransformation1D
 971  */
 972 //=============================================================================
 973 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeMultiTransformation1D
 974                                               (GEOM::GEOM_Object_ptr theBlock,
 975                                                const CORBA::Long     theDirFace1,
 976                                                const CORBA::Long     theDirFace2,
 977                                                const CORBA::Long     theNbTimes)
 978 {
 979   GEOM::GEOM_Object_var aGEOMObject;
 980
 981   //Set a not done flag
 982   GetOperations()->SetNotDone();
 983
 984   //Get the object itself and the vector of translation
 985   Handle(GEOM_Object) aBasicObject = GetObjectImpl(theBlock);
 986   if (aBasicObject.IsNull()) return aGEOMObject._retn();
 987
 988   //Perform the transformation
 989   Handle(GEOM_Object) anObject = GetOperations()->MakeMultiTransformation1D
 990     (aBasicObject, theDirFace1, theDirFace2, theNbTimes);
 991   if (!GetOperations()->IsDone() || anObject.IsNull())  return aGEOMObject._retn();
 992
 993   return GetObject(anObject);
 994 }
 995
 996 //=============================================================================
 997 /*!
 998  *  MakeMultiTransformation2D
 999  */
1000 //=============================================================================
1001 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeMultiTransformation2D
1002                                            (GEOM::GEOM_Object_ptr theBlock,
1003                                             const CORBA::Long     theDirFace1U,
1004                                             const CORBA::Long     theDirFace2U,
1005                                             const CORBA::Long     theNbTimesU,
1006                                             const CORBA::Long     theDirFace1V,
1007                                             const CORBA::Long     theDirFace2V,
1008                                             const CORBA::Long     theNbTimesV)
1009 {
1010   GEOM::GEOM_Object_var aGEOMObject;
1011
1012   //Set a not done flag
1013   GetOperations()->SetNotDone();
1014
1015   //Get the object itself
1016   Handle(GEOM_Object) aBasicObject = GetObjectImpl(theBlock);
1017   if (aBasicObject.IsNull()) return aGEOMObject._retn();
1018
1019   //Perform the transformation
1020   Handle(GEOM_Object) anObject = GetOperations()->MakeMultiTransformation2D
1021     (aBasicObject,
1022      theDirFace1U, theDirFace2U, theNbTimesU,
1023      theDirFace1V, theDirFace2V, theNbTimesV);
1024   if (!GetOperations()->IsDone() || anObject.IsNull()) return aGEOMObject._retn();
1025
1026   return GetObject(anObject);
1027 }
1028
1029 //=============================================================================
1030 /*!
1031  *  Propagate
1032  */
1033 //=============================================================================
1034 GEOM::ListOfGO* GEOM_IBlocksOperations_i::Propagate (GEOM::GEOM_Object_ptr theShape)
1035 {
1036   GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
1037
1038   //Set a not done flag
1039   GetOperations()->SetNotDone();
1040
1041   //Get the reference Shape
1042   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
1043   if (aShape.IsNull()) return aSeq._retn();
1044
1045   //Get the Propagation chains
1046   Handle(TColStd_HSequenceOfTransient) aHSeq =
1047     GetOperations()->Propagate(aShape);
1048   if (!GetOperations()->IsDone() || aHSeq.IsNull())
1049     return aSeq._retn();
1050
1051   Standard_Integer aLength = aHSeq->Length();
1052   aSeq->length(aLength);
1053   for (Standard_Integer i = 1; i <= aLength; i++)
1054     aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
1055
1056   return aSeq._retn();
1057 }