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                                            GEOM::GEOM_IBlocksOperations::BCErrors_out theErrors)
 618 {
 619   CORBA::Boolean isComp = false;
 620
 621   //Set a not done flag
 622   GetOperations()->SetNotDone();
 623
 624   //Get the reference Compound
 625   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 626   if (aCompound.IsNull()) return isComp;
 627
 628   //Check
 629   std::list<GEOMImpl_IBlocksOperations::BCError> errList;
 630   isComp = GetOperations()->CheckCompoundOfBlocks(aCompound, errList);
 631   if (!GetOperations()->IsDone())
 632     return isComp;
 633
 634   const int nbErr = errList.size();
 635   GEOM::GEOM_IBlocksOperations::BCErrors_var anErrArray =
 636     new GEOM::GEOM_IBlocksOperations::BCErrors();
 637   anErrArray->length(nbErr);
 638
 639   // fill the local CORBA array with values from lists
 640   std::list<GEOMImpl_IBlocksOperations::BCError>::iterator errIt = errList.begin();
 641   int i = 0;
 642   for (; errIt != errList.end(); i++, errIt++) {
 643     GEOM::GEOM_IBlocksOperations::BCError_var anError =
 644       new GEOM::GEOM_IBlocksOperations::BCError();
 645
 646     GEOMImpl_IBlocksOperations::BCError errStruct = *errIt;
 647
 648     switch (errStruct.error) {
 649     case GEOMImpl_IBlocksOperations::NOT_BLOCK:
 650       anError->error = GEOM::GEOM_IBlocksOperations::NOT_BLOCK;
 651       break;
 652     case GEOMImpl_IBlocksOperations::EXTRA_EDGE:
 653       anError->error = GEOM::GEOM_IBlocksOperations::EXTRA_EDGE;
 654       break;
 655     case GEOMImpl_IBlocksOperations::INVALID_CONNECTION:
 656       anError->error = GEOM::GEOM_IBlocksOperations::INVALID_CONNECTION;
 657       break;
 658     case GEOMImpl_IBlocksOperations::NOT_CONNECTED:
 659       anError->error = GEOM::GEOM_IBlocksOperations::NOT_CONNECTED;
 660       break;
 661     case GEOMImpl_IBlocksOperations::NOT_GLUED:
 662       anError->error = GEOM::GEOM_IBlocksOperations::NOT_GLUED;
 663       break;
 664     default:
 665       break;
 666     }
 667
 668     std::list<int> sshList = errStruct.incriminated;
 669     GEOM::ListOfLong_var anIncrims = new GEOM::ListOfLong();
 670     anIncrims->length(sshList.size());
 671
 672     std::list<int>::iterator sshIt = sshList.begin();
 673     int jj = 0;
 674     for (; sshIt != sshList.end(); jj++, sshIt++) {
 675       anIncrims[jj] = *sshIt;
 676     }
 677
 678     anError->incriminated = anIncrims;
 679
 680     anErrArray[i] = anError;
 681   }
 682
 683   // initialize out-parameter with local array
 684   theErrors = anErrArray._retn();
 685
 686   return isComp;
 687 }
 688
 689 //=============================================================================
 690 /*!
 691  *  PrintBCErrors
 692  */
 693 //=============================================================================
 694 char* GEOM_IBlocksOperations_i::PrintBCErrors
 695                       (GEOM::GEOM_Object_ptr theCompound,
 696                        const GEOM::GEOM_IBlocksOperations::BCErrors& theErrors)
 697 {
 698   //Get the reference Compound
 699   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 700   if (aCompound.IsNull()) return NULL;
 701
 702   // Convert the errors sequence
 703   std::list<GEOMImpl_IBlocksOperations::BCError> anErrors;
 704   int nbErr = theErrors.length();
 705   int ie = 0;
 706   for (; ie < nbErr; ie++) {
 707     const GEOM::GEOM_IBlocksOperations::BCError err = theErrors[ie];
 708     const GEOM::GEOM_IBlocksOperations::BCErrorType typ = err.error;
 709     const GEOM::ListOfLong incrims = err.incriminated;
 710
 711     GEOMImpl_IBlocksOperations::BCError errStruct;
 712     switch (typ) {
 713     case GEOM::GEOM_IBlocksOperations::NOT_BLOCK:
 714       errStruct.error = GEOMImpl_IBlocksOperations::NOT_BLOCK;
 715       break;
 716     case GEOM::GEOM_IBlocksOperations::EXTRA_EDGE:
 717       errStruct.error = GEOMImpl_IBlocksOperations::EXTRA_EDGE;
 718       break;
 719     case GEOM::GEOM_IBlocksOperations::INVALID_CONNECTION:
 720       errStruct.error = GEOMImpl_IBlocksOperations::INVALID_CONNECTION;
 721       break;
 722     case GEOM::GEOM_IBlocksOperations::NOT_CONNECTED:
 723       errStruct.error = GEOMImpl_IBlocksOperations::NOT_CONNECTED;
 724       break;
 725     case GEOM::GEOM_IBlocksOperations::NOT_GLUED:
 726       errStruct.error = GEOMImpl_IBlocksOperations::NOT_GLUED;
 727       break;
 728     default:
 729       break;
 730     }
 731
 732     int ii = 0;
 733     int aLen = incrims.length();
 734     for (; ii < aLen; ii++) {
 735       errStruct.incriminated.push_back(incrims[ii]);
 736     }
 737
 738     anErrors.push_back(errStruct);
 739   }
 740
 741   TCollection_AsciiString aDescr = GetOperations()->PrintBCErrors(aCompound, anErrors);
 742   return CORBA::string_dup(aDescr.ToCString());
 743 }
 744
 745 //=============================================================================
 746 /*!
 747  *  GetNonBlocks
 748  */
 749 //=============================================================================
 750 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetNonBlocks
 751                                       (GEOM::GEOM_Object_ptr theShape,
 752                                        GEOM::GEOM_Object_out theNonQuads)
 753 {
 754   GEOM::GEOM_Object_var aGEOMObject;
 755   GEOM::GEOM_Object_var aNonQuads;
 756
 757   theNonQuads = aNonQuads._retn();
 758
 759   //Set a not done flag
 760   GetOperations()->SetNotDone();
 761
 762   //Get the reference Objects
 763   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 764   if (aShape.IsNull()) return aGEOMObject._retn();
 765
 766   //Get the result
 767   Handle(GEOM_Object) aFaces;
 768   Handle(GEOM_Object) anObject = GetOperations()->GetNonBlocks(aShape, aFaces);
 769   if (!GetOperations()->IsDone())
 770     return aGEOMObject._retn();
 771
 772   if (!aFaces.IsNull())
 773     theNonQuads = GetObject(aFaces);
 774
 775   if (anObject.IsNull())
 776     return aGEOMObject._retn();
 777
 778   return GetObject(anObject);
 779 }
 780
 781 //=============================================================================
 782 /*!
 783  *  RemoveExtraEdges
 784  */
 785 //=============================================================================
 786 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::RemoveExtraEdges
 787                                       (GEOM::GEOM_Object_ptr theShape,
 788                                        CORBA::Long           theOptimumNbFaces)
 789 {
 790   GEOM::GEOM_Object_var aGEOMObject;
 791
 792   //Set a not done flag
 793   GetOperations()->SetNotDone();
 794
 795   //Get the reference Objects
 796   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 797   if (aShape.IsNull()) return aGEOMObject._retn();
 798
 799   //Get the result
 800   Handle(GEOM_Object) anObject = GetOperations()->RemoveExtraEdges(aShape, theOptimumNbFaces);
 801   if (!GetOperations()->IsDone() || anObject.IsNull())
 802     return aGEOMObject._retn();
 803
 804   return GetObject(anObject);
 805 }
 806
 807 //=============================================================================
 808 /*!
 809  *  UnionFaces
 810  */
 811 //=============================================================================
 812 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::UnionFaces
 813                                       (GEOM::GEOM_Object_ptr theShape)
 814 {
 815   GEOM::GEOM_Object_var aGEOMObject;
 816
 817   //Set a not done flag
 818   GetOperations()->SetNotDone();
 819
 820   //Get the reference Objects
 821   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 822   if (aShape.IsNull()) return aGEOMObject._retn();
 823
 824   //Get the result
 825   Handle(GEOM_Object) anObject = GetOperations()->UnionFaces(aShape);
 826   if (!GetOperations()->IsDone() || anObject.IsNull())
 827     return aGEOMObject._retn();
 828
 829   return GetObject(anObject);
 830 }
 831
 832 //=============================================================================
 833 /*!
 834  *  CheckAndImprove
 835  */
 836 //=============================================================================
 837 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::CheckAndImprove (GEOM::GEOM_Object_ptr theCompound)
 838 {
 839   GEOM::GEOM_Object_var aGEOMObject;
 840
 841   //Set a not done flag
 842   GetOperations()->SetNotDone();
 843
 844   //Get the reference Objects
 845   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 846   if (aCompound.IsNull()) return aGEOMObject._retn();
 847
 848   //Get the result
 849   Handle(GEOM_Object) anObject =
 850     GetOperations()->CheckAndImprove(aCompound);
 851   if (!GetOperations()->IsDone() || anObject.IsNull())
 852     return aGEOMObject._retn();
 853
 854   return GetObject(anObject);
 855 }
 856
 857 //=============================================================================
 858 /*!
 859  *  GetBlockNearPoint
 860  */
 861 //=============================================================================
 862 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetBlockNearPoint (GEOM::GEOM_Object_ptr theCompound,
 863                                                                    GEOM::GEOM_Object_ptr thePoint)
 864 {
 865   GEOM::GEOM_Object_var aGEOMObject;
 866
 867   //Set a not done flag
 868   GetOperations()->SetNotDone();
 869
 870   //Get the reference Objects
 871   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 872   Handle(GEOM_Object) aPoint = GetObjectImpl(thePoint);
 873
 874   if (aCompound.IsNull() || aPoint.IsNull()) return aGEOMObject._retn();
 875
 876   //Get the block
 877   Handle(GEOM_Object) anObject =
 878     GetOperations()->GetBlockNearPoint(aCompound, aPoint);
 879   if (!GetOperations()->IsDone() || anObject.IsNull())
 880     return aGEOMObject._retn();
 881
 882   return GetObject(anObject);
 883 }
 884
 885 //=============================================================================
 886 /*!
 887  *  GetBlockByParts
 888  */
 889 //=============================================================================
 890 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetBlockByParts (GEOM::GEOM_Object_ptr theCompound,
 891                                                                  const GEOM::ListOfGO& theParts)
 892 {
 893   GEOM::GEOM_Object_var aGEOMObject;
 894
 895   //Set a not done flag
 896   GetOperations()->SetNotDone();
 897
 898   //Get the reference Compound
 899   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 900   if (aCompound.IsNull()) return aGEOMObject._retn();
 901
 902   //Get the parts
 903   int ind, aLen;
 904   Handle(TColStd_HSequenceOfTransient) aParts = new TColStd_HSequenceOfTransient;
 905
 906   aLen = theParts.length();
 907   for (ind = 0; ind < aLen; ind++) {
 908     Handle(GEOM_Object) aSh = GetObjectImpl(theParts[ind]);
 909     if (aSh.IsNull()) return aGEOMObject._retn();
 910     aParts->Append(aSh);
 911   }
 912
 913   //Get the Block
 914   Handle(GEOM_Object) anObject =
 915     GetOperations()->GetBlockByParts(aCompound, aParts);
 916   if (!GetOperations()->IsDone() || anObject.IsNull())
 917     return aGEOMObject._retn();
 918
 919   return GetObject(anObject);
 920 }
 921
 922 //=============================================================================
 923 /*!
 924  *  GetBlocksByParts
 925  */
 926 //=============================================================================
 927 GEOM::ListOfGO* GEOM_IBlocksOperations_i::GetBlocksByParts (GEOM::GEOM_Object_ptr theCompound,
 928                                                             const GEOM::ListOfGO& theParts)
 929 {
 930   GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
 931
 932   //Set a not done flag
 933   GetOperations()->SetNotDone();
 934
 935   //Get the reference Compound
 936   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 937   if (aCompound.IsNull()) return aSeq._retn();
 938
 939   //Get the parts
 940   int ind, aLen;
 941   Handle(TColStd_HSequenceOfTransient) aParts = new TColStd_HSequenceOfTransient;
 942
 943   aLen = theParts.length();
 944   for (ind = 0; ind < aLen; ind++) {
 945     Handle(GEOM_Object) aSh = GetObjectImpl(theParts[ind]);
 946     if (aSh.IsNull()) return aSeq._retn();
 947     aParts->Append(aSh);
 948   }
 949
 950   //Get the Block
 951   Handle(TColStd_HSequenceOfTransient) aHSeq =
 952     GetOperations()->GetBlocksByParts(aCompound, aParts);
 953   if (!GetOperations()->IsDone() || aHSeq.IsNull())
 954     return aSeq._retn();
 955
 956   Standard_Integer aLength = aHSeq->Length();
 957   aSeq->length(aLength);
 958   for (Standard_Integer i = 1; i <= aLength; i++)
 959     aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
 960
 961   return aSeq._retn();
 962 }
 963
 964 //=============================================================================
 965 /*!
 966  *  MakeMultiTransformation1D
 967  */
 968 //=============================================================================
 969 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeMultiTransformation1D
 970                                               (GEOM::GEOM_Object_ptr theBlock,
 971                                                const CORBA::Long     theDirFace1,
 972                                                const CORBA::Long     theDirFace2,
 973                                                const CORBA::Long     theNbTimes)
 974 {
 975   GEOM::GEOM_Object_var aGEOMObject;
 976
 977   //Set a not done flag
 978   GetOperations()->SetNotDone();
 979
 980   //Get the object itself and the vector of translation
 981   Handle(GEOM_Object) aBasicObject = GetObjectImpl(theBlock);
 982   if (aBasicObject.IsNull()) return aGEOMObject._retn();
 983
 984   //Perform the transformation
 985   Handle(GEOM_Object) anObject = GetOperations()->MakeMultiTransformation1D
 986     (aBasicObject, theDirFace1, theDirFace2, theNbTimes);
 987   if (!GetOperations()->IsDone() || anObject.IsNull())  return aGEOMObject._retn();
 988
 989   return GetObject(anObject);
 990 }
 991
 992 //=============================================================================
 993 /*!
 994  *  MakeMultiTransformation2D
 995  */
 996 //=============================================================================
 997 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeMultiTransformation2D
 998                                            (GEOM::GEOM_Object_ptr theBlock,
 999                                             const CORBA::Long     theDirFace1U,
1000                                             const CORBA::Long     theDirFace2U,
1001                                             const CORBA::Long     theNbTimesU,
1002                                             const CORBA::Long     theDirFace1V,
1003                                             const CORBA::Long     theDirFace2V,
1004                                             const CORBA::Long     theNbTimesV)
1005 {
1006   GEOM::GEOM_Object_var aGEOMObject;
1007
1008   //Set a not done flag
1009   GetOperations()->SetNotDone();
1010
1011   //Get the object itself
1012   Handle(GEOM_Object) aBasicObject = GetObjectImpl(theBlock);
1013   if (aBasicObject.IsNull()) return aGEOMObject._retn();
1014
1015   //Perform the transformation
1016   Handle(GEOM_Object) anObject = GetOperations()->MakeMultiTransformation2D
1017     (aBasicObject,
1018      theDirFace1U, theDirFace2U, theNbTimesU,
1019      theDirFace1V, theDirFace2V, theNbTimesV);
1020   if (!GetOperations()->IsDone() || anObject.IsNull()) return aGEOMObject._retn();
1021
1022   return GetObject(anObject);
1023 }
1024
1025 //=============================================================================
1026 /*!
1027  *  Propagate
1028  */
1029 //=============================================================================
1030 GEOM::ListOfGO* GEOM_IBlocksOperations_i::Propagate (GEOM::GEOM_Object_ptr theShape)
1031 {
1032   GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
1033
1034   //Set a not done flag
1035   GetOperations()->SetNotDone();
1036
1037   //Get the reference Shape
1038   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
1039   if (aShape.IsNull()) return aSeq._retn();
1040
1041   //Get the Propagation chains
1042   Handle(TColStd_HSequenceOfTransient) aHSeq =
1043     GetOperations()->Propagate(aShape);
1044   if (!GetOperations()->IsDone() || aHSeq.IsNull())
1045     return aSeq._retn();
1046
1047   Standard_Integer aLength = aHSeq->Length();
1048   aSeq->length(aLength);
1049   for (Standard_Integer i = 1; i <= aLength; i++)
1050     aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
1051
1052   return aSeq._retn();
1053 }