src/GEOM_I/GEOM_IBlocksOperations_i.cc

   1 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  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  *  RemoveExtraEdges
 748  */
 749 //=============================================================================
 750 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::RemoveExtraEdges
 751                                       (GEOM::GEOM_Object_ptr theShape,
 752                                        CORBA::Long           theOptimumNbFaces)
 753 {
 754   GEOM::GEOM_Object_var aGEOMObject;
 755
 756   //Set a not done flag
 757   GetOperations()->SetNotDone();
 758
 759   //Get the reference Objects
 760   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 761   if (aShape.IsNull()) return aGEOMObject._retn();
 762
 763   //Get the result
 764   Handle(GEOM_Object) anObject = GetOperations()->RemoveExtraEdges(aShape, theOptimumNbFaces);
 765   if (!GetOperations()->IsDone() || anObject.IsNull())
 766     return aGEOMObject._retn();
 767
 768   return GetObject(anObject);
 769 }
 770
 771 //=============================================================================
 772 /*!
 773  *  CheckAndImprove
 774  */
 775 //=============================================================================
 776 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::CheckAndImprove (GEOM::GEOM_Object_ptr theCompound)
 777 {
 778   GEOM::GEOM_Object_var aGEOMObject;
 779
 780   //Set a not done flag
 781   GetOperations()->SetNotDone();
 782
 783   //Get the reference Objects
 784   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 785   if (aCompound.IsNull()) return aGEOMObject._retn();
 786
 787   //Get the result
 788   Handle(GEOM_Object) anObject =
 789     GetOperations()->CheckAndImprove(aCompound);
 790   if (!GetOperations()->IsDone() || anObject.IsNull())
 791     return aGEOMObject._retn();
 792
 793   return GetObject(anObject);
 794 }
 795
 796 //=============================================================================
 797 /*!
 798  *  GetBlockNearPoint
 799  */
 800 //=============================================================================
 801 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetBlockNearPoint (GEOM::GEOM_Object_ptr theCompound,
 802                                                                    GEOM::GEOM_Object_ptr thePoint)
 803 {
 804   GEOM::GEOM_Object_var aGEOMObject;
 805
 806   //Set a not done flag
 807   GetOperations()->SetNotDone();
 808
 809   //Get the reference Objects
 810   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 811   Handle(GEOM_Object) aPoint = GetObjectImpl(thePoint);
 812
 813   if (aCompound.IsNull() || aPoint.IsNull()) return aGEOMObject._retn();
 814
 815   //Get the block
 816   Handle(GEOM_Object) anObject =
 817     GetOperations()->GetBlockNearPoint(aCompound, aPoint);
 818   if (!GetOperations()->IsDone() || anObject.IsNull())
 819     return aGEOMObject._retn();
 820
 821   return GetObject(anObject);
 822 }
 823
 824 //=============================================================================
 825 /*!
 826  *  GetBlockByParts
 827  */
 828 //=============================================================================
 829 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetBlockByParts (GEOM::GEOM_Object_ptr theCompound,
 830                                                                  const GEOM::ListOfGO& theParts)
 831 {
 832   GEOM::GEOM_Object_var aGEOMObject;
 833
 834   //Set a not done flag
 835   GetOperations()->SetNotDone();
 836
 837   //Get the reference Compound
 838   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 839   if (aCompound.IsNull()) return aGEOMObject._retn();
 840
 841   //Get the parts
 842   int ind, aLen;
 843   Handle(TColStd_HSequenceOfTransient) aParts = new TColStd_HSequenceOfTransient;
 844
 845   aLen = theParts.length();
 846   for (ind = 0; ind < aLen; ind++) {
 847     Handle(GEOM_Object) aSh = GetObjectImpl(theParts[ind]);
 848     if (aSh.IsNull()) return aGEOMObject._retn();
 849     aParts->Append(aSh);
 850   }
 851
 852   //Get the Block
 853   Handle(GEOM_Object) anObject =
 854     GetOperations()->GetBlockByParts(aCompound, aParts);
 855   if (!GetOperations()->IsDone() || anObject.IsNull())
 856     return aGEOMObject._retn();
 857
 858   return GetObject(anObject);
 859 }
 860
 861 //=============================================================================
 862 /*!
 863  *  GetBlocksByParts
 864  */
 865 //=============================================================================
 866 GEOM::ListOfGO* GEOM_IBlocksOperations_i::GetBlocksByParts (GEOM::GEOM_Object_ptr theCompound,
 867                                                             const GEOM::ListOfGO& theParts)
 868 {
 869   GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
 870
 871   //Set a not done flag
 872   GetOperations()->SetNotDone();
 873
 874   //Get the reference Compound
 875   Handle(GEOM_Object) aCompound = GetObjectImpl(theCompound);
 876   if (aCompound.IsNull()) return aSeq._retn();
 877
 878   //Get the parts
 879   int ind, aLen;
 880   Handle(TColStd_HSequenceOfTransient) aParts = new TColStd_HSequenceOfTransient;
 881
 882   aLen = theParts.length();
 883   for (ind = 0; ind < aLen; ind++) {
 884     Handle(GEOM_Object) aSh = GetObjectImpl(theParts[ind]);
 885     if (aSh.IsNull()) return aSeq._retn();
 886     aParts->Append(aSh);
 887   }
 888
 889   //Get the Block
 890   Handle(TColStd_HSequenceOfTransient) aHSeq =
 891     GetOperations()->GetBlocksByParts(aCompound, aParts);
 892   if (!GetOperations()->IsDone() || aHSeq.IsNull())
 893     return aSeq._retn();
 894
 895   Standard_Integer aLength = aHSeq->Length();
 896   aSeq->length(aLength);
 897   for (Standard_Integer i = 1; i <= aLength; i++)
 898     aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
 899
 900   return aSeq._retn();
 901 }
 902
 903 //=============================================================================
 904 /*!
 905  *  MakeMultiTransformation1D
 906  */
 907 //=============================================================================
 908 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeMultiTransformation1D
 909                                               (GEOM::GEOM_Object_ptr theBlock,
 910                                                const CORBA::Long     theDirFace1,
 911                                                const CORBA::Long     theDirFace2,
 912                                                const CORBA::Long     theNbTimes)
 913 {
 914   GEOM::GEOM_Object_var aGEOMObject;
 915
 916   //Set a not done flag
 917   GetOperations()->SetNotDone();
 918
 919   //Get the object itself and the vector of translation
 920   Handle(GEOM_Object) aBasicObject = GetObjectImpl(theBlock);
 921   if (aBasicObject.IsNull()) return aGEOMObject._retn();
 922
 923   //Perform the transformation
 924   Handle(GEOM_Object) anObject = GetOperations()->MakeMultiTransformation1D
 925     (aBasicObject, theDirFace1, theDirFace2, theNbTimes);
 926   if (!GetOperations()->IsDone() || anObject.IsNull())  return aGEOMObject._retn();
 927
 928   return GetObject(anObject);
 929 }
 930
 931 //=============================================================================
 932 /*!
 933  *  MakeMultiTransformation2D
 934  */
 935 //=============================================================================
 936 GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::MakeMultiTransformation2D
 937                                            (GEOM::GEOM_Object_ptr theBlock,
 938                                             const CORBA::Long     theDirFace1U,
 939                                             const CORBA::Long     theDirFace2U,
 940                                             const CORBA::Long     theNbTimesU,
 941                                             const CORBA::Long     theDirFace1V,
 942                                             const CORBA::Long     theDirFace2V,
 943                                             const CORBA::Long     theNbTimesV)
 944 {
 945   GEOM::GEOM_Object_var aGEOMObject;
 946
 947   //Set a not done flag
 948   GetOperations()->SetNotDone();
 949
 950   //Get the object itself
 951   Handle(GEOM_Object) aBasicObject = GetObjectImpl(theBlock);
 952   if (aBasicObject.IsNull()) return aGEOMObject._retn();
 953
 954   //Perform the transformation
 955   Handle(GEOM_Object) anObject = GetOperations()->MakeMultiTransformation2D
 956     (aBasicObject,
 957      theDirFace1U, theDirFace2U, theNbTimesU,
 958      theDirFace1V, theDirFace2V, theNbTimesV);
 959   if (!GetOperations()->IsDone() || anObject.IsNull()) return aGEOMObject._retn();
 960
 961   return GetObject(anObject);
 962 }
 963
 964 //=============================================================================
 965 /*!
 966  *  Propagate
 967  */
 968 //=============================================================================
 969 GEOM::ListOfGO* GEOM_IBlocksOperations_i::Propagate (GEOM::GEOM_Object_ptr theShape)
 970 {
 971   GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
 972
 973   //Set a not done flag
 974   GetOperations()->SetNotDone();
 975
 976   //Get the reference Shape
 977   Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
 978   if (aShape.IsNull()) return aSeq._retn();
 979
 980   //Get the Propagation chains
 981   Handle(TColStd_HSequenceOfTransient) aHSeq =
 982     GetOperations()->Propagate(aShape);
 983   if (!GetOperations()->IsDone() || aHSeq.IsNull())
 984     return aSeq._retn();
 985
 986   Standard_Integer aLength = aHSeq->Length();
 987   aSeq->length(aLength);
 988   for (Standard_Integer i = 1; i <= aLength; i++)
 989     aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
 990
 991   return aSeq._retn();
 992 }