]> SALOME platform Git repositories - plugins/blsurfplugin.git/blob - src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx
Salome HOME
09679d6a352754e48225884db45dd1def2e44311
[plugins/blsurfplugin.git] / src / BLSURFPlugin / BLSURFPlugin_Hypothesis_i.cxx
1 // Copyright (C) 2007-2023  CEA, EDF
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 // ---
21 // File    : BLSURFPlugin_Hypothesis.cxx
22 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
23 //           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
24 // ---
25 //
26 #include "BLSURFPlugin_Hypothesis_i.hxx"
27 #include "BLSURFPlugin_BLSURF.hxx"
28
29 #include <SMESH_Gen.hxx>
30 #include <SMESH_Gen_i.hxx>
31 #include <SMESH_Group_i.hxx>
32 #include <SMESH_PythonDump.hxx>
33
34 #include <SALOMEDS_wrap.hxx>
35 #include <Utils_CorbaException.hxx>
36 #include <utilities.h>
37
38 #include <stdexcept>
39 #include <cstring>
40 #include <boost/regex.hpp>
41
42 using namespace std;
43
44 namespace
45 {
46   //================================================================================
47   /*!
48    * \brief Return persistent ID of a mesh
49    *  \param [in] mesh - the mesh
50    *  \return int - -1 in case of failure
51    */
52   //================================================================================
53
54   int GetMeshPersistentId( SMESH::SMESH_Mesh_ptr mesh )
55   {
56     int id = -1;
57     if ( SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh ))
58       id = mesh_i->GetImpl().GetMeshDS()->GetPersistentId();
59     return id;
60   }
61
62   //================================================================================
63   /*!
64    * \brief Return persistent ID of a group or sub-mesh
65    *  \param [in] meshPart - the mesh part
66    *  \param [out] isGroup - return true if meshPart is a group
67    *  \return int - -1 in case if meshPart is neither a group nor a sub-mesh
68    */
69   //================================================================================
70
71   int GetMeshPartPersistentId( SMESH::SMESH_IDSource_ptr meshPart, bool & isGroup )
72   {
73     int id = -1;
74     isGroup = false;
75     SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>( meshPart );
76     if ( group_i )
77     {
78       id = group_i->GetLocalID();
79       isGroup = true;
80     }
81     else
82     {
83       SMESH::SMESH_subMesh_var subMesh = SMESH::SMESH_subMesh::_narrow( meshPart );
84       if ( !subMesh->_is_nil() )
85         id = subMesh->GetId();
86     }
87     return id;
88   }
89
90   //================================================================================
91   /*!
92    * \brief Find a mesh in the study by mesh persistent ID
93    */
94   //================================================================================
95
96   SMESH::SMESH_Mesh_ptr FindMeshByID( int theMeshID )
97   {
98     SMESH::SMESH_Mesh_var mesh;
99
100     SMESH_Gen_i*                gen = SMESH_Gen_i::GetSMESHGen();
101     CORBA::String_var  compDataType = gen->ComponentDataType();
102     SALOMEDS::Study_var      aStudy = gen->getStudyServant();
103     SALOMEDS::SComponent_wrap genSO = aStudy->FindComponent( compDataType.in() );
104     if ( !genSO->_is_nil() )
105     {
106       SALOMEDS::ChildIterator_wrap anIter = aStudy->NewChildIterator( genSO );
107       for ( ; anIter->More(); anIter->Next() )
108       {
109         SALOMEDS::SObject_wrap so = anIter->Value();
110         CORBA::Object_var      obj = gen->SObjectToObject( so );
111         mesh = SMESH::SMESH_Mesh::_narrow( obj );
112         if ( !mesh->_is_nil() && GetMeshPersistentId( mesh ) == theMeshID )
113           break;
114         mesh = SMESH::SMESH_Mesh::_nil();
115       }
116     }
117     return mesh._retn();
118   }
119
120   //================================================================================
121   /*!
122    * \brief Return a group by its ID
123    */
124   //================================================================================
125
126   SMESH::SMESH_GroupBase_ptr GetGroupByID( SMESH::SMESH_Mesh_ptr mesh, int ID )
127   {
128     SMESH::SMESH_GroupBase_var group;
129     if ( !CORBA::is_nil( mesh ))
130     {
131       SMESH::ListOfGroups_var groups = mesh->GetGroups();
132       for ( CORBA::ULong i = 0; i < groups->length(); ++i )
133         if ( SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>( groups[i] ))
134           if ( group_i->GetLocalID() == ID )
135           {
136             group = SMESH::SMESH_GroupBase::_narrow( groups[i] );
137             break;
138           }
139     }
140     return group._retn();
141   }
142
143   //================================================================================
144   /*!
145    * \brief Return a sub-mesh by sub-shape ID
146    */
147   //================================================================================
148
149   SMESH::SMESH_subMesh_ptr GetSubMeshByID( SMESH::SMESH_Mesh_ptr mesh,
150                                            const int             shapeID,
151                                            CORBA::Long           subMeshTag )
152   {
153     SMESH::SMESH_subMesh_var subMesh;
154     if ( !CORBA::is_nil( mesh ))
155     {
156       SMESH_Gen_i*              gen = SMESH_Gen_i::GetSMESHGen();
157       SALOMEDS::SObject_wrap meshSO = gen->ObjectToSObject( mesh );
158       SALOMEDS::Study_var    aStudy = gen->getStudyServant();
159       SALOMEDS::SObject_wrap subMeshRootSO;
160       if ( !meshSO->_is_nil() && meshSO->FindSubObject( subMeshTag, subMeshRootSO.inout() ))
161       {
162         SALOMEDS::ChildIterator_wrap anIter = aStudy->NewChildIterator( subMeshRootSO );
163         for ( ; anIter->More(); anIter->Next() )
164         {
165           SALOMEDS::SObject_wrap so = anIter->Value();
166           CORBA::Object_var      obj = gen->SObjectToObject( so );
167           subMesh = SMESH::SMESH_subMesh::_narrow( obj );
168           if ( !subMesh->_is_nil() && subMesh->GetId() == shapeID )
169             break;
170           subMesh = SMESH::SMESH_subMesh::_nil();
171         }
172       }
173       return subMesh._retn();
174     }
175     return subMesh._retn();
176   }
177
178 } // namespace
179
180 //=============================================================================
181 /*!
182  *  BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i
183  *
184  *  Constructor
185  */
186 //=============================================================================
187 BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr thePOA,
188                                                      ::SMESH_Gen*            theGenImpl,
189                                                      bool                    theHasGEOM) :
190   SALOME::GenericObj_i(thePOA), SMESH_Hypothesis_i(thePOA)
191 {
192   myBaseImpl = new ::BLSURFPlugin_Hypothesis(theGenImpl->GetANewId(),
193                                              
194                                              theGenImpl,
195                                              theHasGEOM);
196 }
197
198 //=============================================================================
199 /*!
200  *  BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i
201  *
202  *  Destructor
203  */
204 //=============================================================================
205 BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i()
206 {
207 }
208
209 //=============================================================================
210 /*!
211  *  BLSURFPlugin_Hypothesis_i::GetMeshGemsVersion
212  *
213  *  Get version of MeshGems suite.
214  */
215 //=============================================================================
216 char* BLSURFPlugin_Hypothesis_i::GetMeshGemsVersion()
217 {
218   return CORBA::string_dup( this->GetImpl()->GetMeshGemsVersion().c_str() );
219 }
220
221 //=============================================================================
222 /*!
223  *  BLSURFPlugin_Hypothesis_i::SetPhysicalMesh
224  *
225  *  Set PhysicalMesh
226  */
227 //=============================================================================
228 void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh(CORBA::Long theValue)
229 {
230   ASSERT(myBaseImpl);
231   this->GetImpl()->SetPhysicalMesh((::BLSURFPlugin_Hypothesis::PhysicalMesh) theValue);
232   SMESH::TPythonDump() << _this() << ".SetPhysicalMesh( " << theValue << " )";
233 }
234
235 //=============================================================================
236 /*!
237  *  BLSURFPlugin_Hypothesis_i::GetPhysicalMesh
238  *
239  *  Get PhysicalMesh
240  */
241 //=============================================================================
242 CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh()
243 {
244   ASSERT(myBaseImpl);
245   return this->GetImpl()->GetPhysicalMesh();
246 }
247
248 //=============================================================================
249 /*!
250  *  BLSURFPlugin_Hypothesis_i::SetGeometricMesh
251  *
252  *  Set GeometricMesh
253  */
254
255 //=============================================================================
256 void BLSURFPlugin_Hypothesis_i::SetGeometricMesh(CORBA::Long theValue)
257 {
258   ASSERT(myBaseImpl);
259   this->GetImpl()->SetGeometricMesh((::BLSURFPlugin_Hypothesis::GeometricMesh) theValue);
260   SMESH::TPythonDump() << _this() << ".SetGeometricMesh( " << theValue << " )";
261 }
262
263 //=============================================================================
264 /*!
265  *  BLSURFPlugin_Hypothesis_i::GetGeometricMesh
266  *
267  *  Get GeometricMesh
268  */
269 //=============================================================================
270 CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh()
271 {
272   ASSERT(myBaseImpl);
273   return this->GetImpl()->GetGeometricMesh();
274 }
275
276 //=============================================================================
277 /*!
278  *  BLSURFPlugin_Hypothesis_i::SetPhySize
279  *
280  *  Set PhySize
281  */
282 //=============================================================================
283 void BLSURFPlugin_Hypothesis_i::SetPhySize(CORBA::Double theValue)
284 {
285   ASSERT(myBaseImpl);
286   this->GetImpl()->SetPhySize(theValue, false);
287   SMESH::TPythonDump() << _this() << ".SetPhySize( " << theValue << " )";
288 }
289
290 //=============================================================================
291 /*!
292  *  BLSURFPlugin_Hypothesis_i::SetPhySizeRel
293  *
294  *  Set Relative PhySize
295  */
296 //=============================================================================
297 void BLSURFPlugin_Hypothesis_i::SetPhySizeRel(CORBA::Double theValue)
298 {
299   ASSERT(myBaseImpl);
300   this->GetImpl()->SetPhySize(theValue, true);
301   SMESH::TPythonDump() << _this() << ".SetPhySizeRel( " << theValue << " )";
302 }
303
304 //=============================================================================
305 /*!
306  *  BLSURFPlugin_Hypothesis_i::GetPhySize
307  *
308  *  Get PhySize
309  */
310 //=============================================================================
311 CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize()
312 {
313   ASSERT(myBaseImpl);
314   return this->GetImpl()->GetPhySize();
315 }
316
317 //=============================================================================
318 /*!
319  *  BLSURFPlugin_Hypothesis_i::IsPhySizeRel
320  *
321  *  Returns True if PhySize is relative
322  */
323 //=============================================================================
324 CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsPhySizeRel()
325 {
326   ASSERT(myBaseImpl);
327   return this->GetImpl()->IsPhySizeRel();
328 }
329
330 //=============================================================================
331 void BLSURFPlugin_Hypothesis_i::SetMinSize(CORBA::Double theMinSize)
332 {
333   if (IsMinSizeRel() || GetMinSize() != theMinSize ) {
334     this->GetImpl()->SetMinSize(theMinSize, false);
335     SMESH::TPythonDump() << _this() << ".SetMinSize( " << theMinSize << " )";
336   }
337 }
338
339 //=============================================================================
340 void BLSURFPlugin_Hypothesis_i::SetMinSizeRel(CORBA::Double theMinSize)
341 {
342   if ( !IsMinSizeRel() || (GetMinSize() != theMinSize) ) {
343     this->GetImpl()->SetMinSize(theMinSize, true);
344     SMESH::TPythonDump() << _this() << ".SetMinSizeRel( " << theMinSize << " )";
345   }
346 }
347
348 //=============================================================================
349 CORBA::Double BLSURFPlugin_Hypothesis_i::GetMinSize()
350 {
351   return this->GetImpl()->GetMinSize();
352 }
353
354 //=============================================================================
355 CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMinSizeRel()
356 {
357   return this->GetImpl()->IsMinSizeRel();
358 }
359
360 //=============================================================================
361 void BLSURFPlugin_Hypothesis_i::SetMaxSize(CORBA::Double theMaxSize)
362 {
363   if (IsMaxSizeRel() || GetMaxSize() != theMaxSize) {
364     this->GetImpl()->SetMaxSize(theMaxSize, false);
365     SMESH::TPythonDump() << _this() << ".SetMaxSize( " << theMaxSize << " )";
366   }
367 }
368
369 //=============================================================================
370 void BLSURFPlugin_Hypothesis_i::SetMaxSizeRel(CORBA::Double theMaxSize)
371 {
372   if ( !IsMaxSizeRel() || (GetMaxSize() != theMaxSize) ) {
373     this->GetImpl()->SetMaxSize(theMaxSize, true);
374     SMESH::TPythonDump() << _this() << ".SetMaxSizeRel( " << theMaxSize << " )";
375   }
376 }
377
378 //=============================================================================
379 CORBA::Double BLSURFPlugin_Hypothesis_i::GetMaxSize()
380 {
381   return this->GetImpl()->GetMaxSize();
382 }
383
384 //=============================================================================
385 CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMaxSizeRel()
386 {
387   return this->GetImpl()->IsMaxSizeRel();
388 }
389
390
391 //=============================================================================
392 /*!
393  *  BLSURFPlugin_Hypothesis_i::SetUseGradation
394  *
395  *  Set true or false
396  */
397 //=============================================================================
398 void BLSURFPlugin_Hypothesis_i::SetUseGradation(CORBA::Boolean theValue)
399 {
400   if ( GetImpl()->GetUseGradation() != bool( theValue ))
401   {
402     this->GetImpl()->SetUseGradation(theValue);
403     std::string theValueStr = theValue ? "True" : "False";
404     SMESH::TPythonDump() << _this() << ".SetUseGradation( " << theValueStr.c_str() << " )";
405   }
406 }
407
408 //=============================================================================
409 /*!
410  *  BLSURFPlugin_Hypothesis_i::GetUseGradation
411  *
412  *  Get true or false
413  */
414 //=============================================================================
415 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseGradation()
416 {
417   return this->GetImpl()->GetUseGradation();
418 }
419
420 //=============================================================================
421 /*!
422  *  BLSURFPlugin_Hypothesis_i::SetGradation
423  *
424  *  Set Gradation
425  */
426 //=============================================================================
427 void BLSURFPlugin_Hypothesis_i::SetGradation(CORBA::Double theValue)
428 {
429   this->GetImpl()->SetGradation(theValue);
430
431   if ( theValue < 0 )
432     SetUseGradation( false );
433   else
434     SMESH::TPythonDump() << _this() << ".SetGradation( " << theValue << " )";
435 }
436
437 //=============================================================================
438 /*!
439  *  BLSURFPlugin_Hypothesis_i::GetGradation
440  *
441  *  Get Gradation
442  */
443 //=============================================================================
444 CORBA::Double BLSURFPlugin_Hypothesis_i::GetGradation()
445 {
446   return this->GetImpl()->GetGradation();
447 }
448
449 //=============================================================================
450 /*!
451  *  BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation
452  *
453  *  Set true or false
454  */
455 //=============================================================================
456 void BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation(CORBA::Boolean theValue)
457 {
458   if ( GetImpl()->GetUseVolumeGradation() != bool( theValue ))
459   {
460     this->GetImpl()->SetUseVolumeGradation(theValue);
461     std::string theValueStr = theValue ? "True" : "False";
462     SMESH::TPythonDump() << _this() << ".SetUseVolumeGradation( " << theValueStr.c_str() << " )";
463   }
464 }
465
466 //=============================================================================
467 /*!
468  *  BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation
469  *
470  *  Get true or false
471  */
472 //=============================================================================
473 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation()
474 {
475   return this->GetImpl()->GetUseVolumeGradation();
476 }
477
478 //=============================================================================
479 /*!
480  *  BLSURFPlugin_Hypothesis_i::SetVolumeGradation
481  *
482  *  Set VolumeGradation
483  */
484 //=============================================================================
485 void BLSURFPlugin_Hypothesis_i::SetVolumeGradation(CORBA::Double theValue)
486 {
487   this->GetImpl()->SetVolumeGradation(theValue);
488   if ( theValue < 0 )
489     SetUseVolumeGradation( false );
490   else
491     SMESH::TPythonDump() << _this() << ".SetVolumeGradation( " << theValue << " )";
492 }
493
494 //=============================================================================
495 /*!
496  *  BLSURFPlugin_Hypothesis_i::GetVolumeGradation
497  *
498  *  Get VolumeGradation
499  */
500 //=============================================================================
501 CORBA::Double BLSURFPlugin_Hypothesis_i::GetVolumeGradation()
502 {
503   return this->GetImpl()->GetVolumeGradation();
504 }
505
506 //=============================================================================
507 /*!
508  *  BLSURFPlugin_Hypothesis_i::SetQuadAllowed
509  *
510  *  Set true or false
511  *
512  *  DEPRACATED, kept for python script compatibility
513  *
514  *  TO be removed in Salome 9
515  */
516 //=============================================================================
517 void BLSURFPlugin_Hypothesis_i::SetQuadAllowed(CORBA::Boolean theValue)
518 {
519   ::BLSURFPlugin_Hypothesis::ElementType theElementType = theValue ?
520                   ::BLSURFPlugin_Hypothesis::QuadrangleDominant : ::BLSURFPlugin_Hypothesis::Triangles;
521   this->GetImpl()->SetElementType(theElementType);
522   SMESH::TPythonDump() << _this() << ".SetElementType( " << theElementType << " )";
523 }
524
525 //=============================================================================
526 /*!
527  *  BLSURFPlugin_Hypothesis_i::SetElementType
528  *
529  *  Set ElementType
530  */
531 //=============================================================================
532 void BLSURFPlugin_Hypothesis_i::SetElementType(CORBA::Long theValue)
533 {
534   this->GetImpl()->SetElementType((::BLSURFPlugin_Hypothesis::ElementType) theValue);
535   SMESH::TPythonDump() << _this() << ".SetElementType( " << theValue << " )";
536 }
537 //=============================================================================
538 /*!
539  *  BLSURFPlugin_Hypothesis_i::GetElementType
540  *
541  *  Get ElementType
542  */
543 //=============================================================================
544 CORBA::Long BLSURFPlugin_Hypothesis_i::GetElementType()
545 {
546   return this->GetImpl()->GetElementType();
547 }
548
549 //=============================================================================
550 /*!
551  *  BLSURFPlugin_Hypothesis_i::SetAngleMesh
552  *
553  *  Set AngleMesh
554  */
555 //=============================================================================
556 void BLSURFPlugin_Hypothesis_i::SetAngleMesh(CORBA::Double theValue)
557 {
558   this->GetImpl()->SetAngleMesh(theValue);
559   SMESH::TPythonDump() << _this() << ".SetAngleMesh( " << theValue << " )";
560 }
561
562 //=============================================================================
563 /*!
564  *  BLSURFPlugin_Hypothesis_i::GetAngleMesh
565  *
566  *  Get AngleMesh
567  */
568 //=============================================================================
569 CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMesh()
570 {
571   return this->GetImpl()->GetAngleMesh();
572 }
573
574 //=============================================================================
575 /*!
576  *  BLSURFPlugin_Hypothesis_i::SetChordalError
577  *
578  *  Set Chordal Error
579  */
580 //=============================================================================
581 void BLSURFPlugin_Hypothesis_i::SetChordalError(CORBA::Double theValue)
582 {
583   this->GetImpl()->SetChordalError(theValue);
584   SMESH::TPythonDump() << _this() << ".SetChordalError( " << theValue << " )";
585 }
586
587 //=============================================================================
588 /*!
589  *  BLSURFPlugin_Hypothesis_i::GetChordalError
590  *
591  *  Get Chordal Error
592  */
593 //=============================================================================
594 CORBA::Double BLSURFPlugin_Hypothesis_i::GetChordalError()
595 {
596   return this->GetImpl()->GetChordalError();
597 }
598
599 //=============================================================================
600 /*!
601  *  BLSURFPlugin_Hypothesis_i::SetAnisotropic
602  *
603  *  Set true or false
604  */
605 //=============================================================================
606 void BLSURFPlugin_Hypothesis_i::SetAnisotropic(CORBA::Boolean theValue)
607 {
608   this->GetImpl()->SetAnisotropic(theValue);
609   std::string theValueStr = theValue ? "True" : "False";
610   SMESH::TPythonDump() << _this() << ".SetAnisotropic( " << theValueStr.c_str() << " )";
611 }
612
613 //=============================================================================
614 /*!
615  *  BLSURFPlugin_Hypothesis_i::GetAnisotropic
616  *
617  *  Get true or false
618  */
619 //=============================================================================
620 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetAnisotropic()
621 {
622   return this->GetImpl()->GetAnisotropic();
623 }
624
625 //=============================================================================
626 /*!
627  *  BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio
628  *
629  *  Set Anisotropic Ratio
630  */
631 //=============================================================================
632 void BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio(CORBA::Double theValue)
633 {
634   this->GetImpl()->SetAnisotropicRatio(theValue);
635   SMESH::TPythonDump() << _this() << ".SetAnisotropicRatio( " << theValue << " )";
636 }
637
638 //=============================================================================
639 /*!
640  *  BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio
641  *
642  *  Get Anisotropic Ratio
643  */
644 //=============================================================================
645 CORBA::Double BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio()
646 {
647   return this->GetImpl()->GetAnisotropicRatio();
648 }
649
650
651 //=============================================================================
652 /*!
653  *  BLSURFPlugin_Hypothesis_i::SetRemoveTinyEdges
654  *
655  *  Set true or false
656  */
657 //=============================================================================
658 void BLSURFPlugin_Hypothesis_i::SetRemoveTinyEdges(CORBA::Boolean theValue) {
659   ASSERT(myBaseImpl);
660   this->GetImpl()->SetRemoveTinyEdges(theValue);
661   std::string theValueStr = theValue ? "True" : "False";
662   SMESH::TPythonDump() << _this() << ".SetRemoveTinyEdges( " << theValueStr.c_str() << " )";
663 }
664
665 //=============================================================================
666 /*!
667  *  BLSURFPlugin_Hypothesis_i::GetRemoveTinyEdges
668  *
669  *  Get true or false
670  */
671 //=============================================================================
672 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetRemoveTinyEdges() {
673   ASSERT(myBaseImpl);
674   return this->GetImpl()->GetRemoveTinyEdges();
675 }
676
677 //=============================================================================
678 /*!
679  *  BLSURFPlugin_Hypothesis_i::SetTinyEdgeLength
680  *
681  *  Set Tiny Edge Length
682  */
683 //=============================================================================
684 void BLSURFPlugin_Hypothesis_i::SetTinyEdgeLength(CORBA::Double theValue) {
685   ASSERT(myBaseImpl);
686   this->GetImpl()->SetTinyEdgeLength(theValue);
687   SMESH::TPythonDump() << _this() << ".SetTinyEdgeLength( " << theValue << " )";
688 }
689
690 //=============================================================================
691 /*!
692  *  BLSURFPlugin_Hypothesis_i::GetTinyEdgeLength
693  *
694  *  Get Tiny Edge Length
695  */
696 //=============================================================================
697 CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeLength() {
698   ASSERT(myBaseImpl);
699   return this->GetImpl()->GetTinyEdgeLength();
700 }
701
702 //=============================================================================
703 /*!
704  *  BLSURFPlugin_Hypothesis_i::SetOptimiseTinyEdges
705  *
706  *  Set true or false
707  */
708 //=============================================================================
709 void BLSURFPlugin_Hypothesis_i::SetOptimiseTinyEdges(CORBA::Boolean theValue) {
710   ASSERT(myBaseImpl);
711   this->GetImpl()->SetOptimiseTinyEdges(theValue);
712   std::string theValueStr = theValue ? "True" : "False";
713   SMESH::TPythonDump() << _this() << ".SetOptimiseTinyEdges( " << theValueStr.c_str() << " )";
714 }
715
716 //=============================================================================
717 /*!
718  *  BLSURFPlugin_Hypothesis_i::GetOptimiseTinyEdges
719  *
720  *  Get true or false
721  */
722 //=============================================================================
723 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimiseTinyEdges() {
724   ASSERT(myBaseImpl);
725   return this->GetImpl()->GetOptimiseTinyEdges();
726 }
727
728 //=============================================================================
729 /*!
730  *  BLSURFPlugin_Hypothesis_i::SetTinyEdgeOptimisationLength
731  *
732  *  Set Tiny Edge OptimisationLength
733  */
734 //=============================================================================
735 void BLSURFPlugin_Hypothesis_i::SetTinyEdgeOptimisationLength(CORBA::Double theValue) {
736   ASSERT(myBaseImpl);
737   this->GetImpl()->SetTinyEdgeOptimisationLength(theValue);
738   SMESH::TPythonDump() << _this() << ".SetTinyEdgeOptimisationLength( " << theValue << " )";
739 }
740
741 //=============================================================================
742 /*!
743  *  BLSURFPlugin_Hypothesis_i::GetTinyEdgeOptimisationLength
744  *
745  *  Get Tiny Edge OptimisationLength
746  */
747 //=============================================================================
748 CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeOptimisationLength() {
749   ASSERT(myBaseImpl);
750   return this->GetImpl()->GetTinyEdgeOptimisationLength();
751 }
752
753 //=============================================================================
754 /*!
755  *  BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersection
756  *
757  *  Set true or false
758  */
759 //=============================================================================
760 void BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersection(CORBA::Boolean theValue) {
761   ASSERT(myBaseImpl);
762   this->GetImpl()->SetCorrectSurfaceIntersection(theValue);
763   std::string theValueStr = theValue ? "True" : "False";
764   SMESH::TPythonDump() << _this() << ".SetCorrectSurfaceIntersection( " << theValueStr.c_str() << " )";
765 }
766
767 //=============================================================================
768 /*!
769  *  BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersection
770  *
771  *  Get true or false
772  */
773 //=============================================================================
774 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersection() {
775   ASSERT(myBaseImpl);
776   return this->GetImpl()->GetCorrectSurfaceIntersection();
777 }
778
779 //=============================================================================
780 /*!
781  *  BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersectionMaxCost
782  *
783  *  Set Tiny Edge OptimisationLength
784  */
785 //=============================================================================
786 void BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersectionMaxCost(CORBA::Double theValue) {
787   ASSERT(myBaseImpl);
788   this->GetImpl()->SetCorrectSurfaceIntersectionMaxCost(theValue);
789   SMESH::TPythonDump() << _this() << ".SetCorrectSurfaceIntersectionMaxCost( " << theValue << " )";
790 }
791
792 //=============================================================================
793 /*!
794  *  BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersectionMaxCost
795  *
796  *  Get Tiny Edge OptimisationLength
797  */
798 //=============================================================================
799 CORBA::Double BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersectionMaxCost() {
800   ASSERT(myBaseImpl);
801   return this->GetImpl()->GetCorrectSurfaceIntersectionMaxCost();
802 }
803
804 //=============================================================================
805 /*!
806  *  BLSURFPlugin_Hypothesis_i::SetBadElementRemoval
807  *
808  *  Set true or false
809  */
810 //=============================================================================
811 void BLSURFPlugin_Hypothesis_i::SetBadElementRemoval(CORBA::Boolean theValue) {
812   ASSERT(myBaseImpl);
813   this->GetImpl()->SetBadElementRemoval(theValue);
814   std::string theValueStr = theValue ? "True" : "False";
815   SMESH::TPythonDump() << _this() << ".SetBadElementRemoval( " << theValueStr.c_str() << " )";
816 }
817
818 //=============================================================================
819 /*!
820  *  BLSURFPlugin_Hypothesis_i::GetBadElementRemoval
821  *
822  *  Get true or false
823  */
824 //=============================================================================
825 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetBadElementRemoval() {
826   ASSERT(myBaseImpl);
827   return this->GetImpl()->GetBadElementRemoval();
828 }
829
830 //=============================================================================
831 /*!
832  *  BLSURFPlugin_Hypothesis_i::SetBadElementAspectRatio
833  *
834  *  Set Bad Surface Element Aspect Ratio
835  */
836 //=============================================================================
837 void BLSURFPlugin_Hypothesis_i::SetBadElementAspectRatio(CORBA::Double theValue) {
838   ASSERT(myBaseImpl);
839   this->GetImpl()->SetBadElementAspectRatio(theValue);
840   SMESH::TPythonDump() << _this() << ".SetBadElementAspectRatio( " << theValue << " )";
841 }
842
843 //=============================================================================
844 /*!
845  *  BLSURFPlugin_Hypothesis_i::GetBadElementAspectRatio
846  *
847  *  Get Bad Surface Element Aspect Ratio
848  */
849 //=============================================================================
850 CORBA::Double BLSURFPlugin_Hypothesis_i::GetBadElementAspectRatio() {
851   ASSERT(myBaseImpl);
852   return this->GetImpl()->GetBadElementAspectRatio();
853 }
854
855 //=============================================================================
856 /*!
857  *  BLSURFPlugin_Hypothesis_i::SetOptimizeMesh
858  *
859  *  Set true or false
860  */
861 //=============================================================================
862 void BLSURFPlugin_Hypothesis_i::SetOptimizeMesh(CORBA::Boolean theValue) {
863   ASSERT(myBaseImpl);
864   this->GetImpl()->SetOptimizeMesh(theValue);
865   std::string theValueStr = theValue ? "True" : "False";
866   SMESH::TPythonDump() << _this() << ".SetOptimizeMesh( " << theValueStr.c_str() << " )";
867 }
868
869 //=============================================================================
870 /*!
871  *  BLSURFPlugin_Hypothesis_i::GetOptimizeMesh
872  *
873  *  Get true or false
874  */
875 //=============================================================================
876 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimizeMesh() {
877   ASSERT(myBaseImpl);
878   return this->GetImpl()->GetOptimizeMesh();
879 }
880
881 //=============================================================================
882 /*!
883  *  BLSURFPlugin_Hypothesis_i::SetQuadraticMesh
884  *
885  *  Set true or false
886  */
887 //=============================================================================
888 void BLSURFPlugin_Hypothesis_i::SetQuadraticMesh(CORBA::Boolean theValue) {
889   ASSERT(myBaseImpl);
890   this->GetImpl()->SetQuadraticMesh(theValue);
891   std::string theValueStr = theValue ? "True" : "False";
892   SMESH::TPythonDump() << _this() << ".SetQuadraticMesh( " << theValueStr.c_str() << " )";
893 }
894
895 //=============================================================================
896 /*!
897  *  BLSURFPlugin_Hypothesis_i::GetQuadraticMesh
898  *
899  *  Get true or false
900  */
901 //=============================================================================
902 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadraticMesh() {
903   ASSERT(myBaseImpl);
904   return this->GetImpl()->GetQuadraticMesh();
905 }
906
907
908
909
910
911 /*!
912  *  BLSURFPlugin_Hypothesis_i::SetTopology
913  *
914  *  Set topology
915  */
916
917 //=============================================================================
918 void BLSURFPlugin_Hypothesis_i::SetTopology(CORBA::Long theValue) {
919   ASSERT(myBaseImpl);
920   this->GetImpl()->SetTopology((::BLSURFPlugin_Hypothesis::Topology) theValue);
921   SMESH::TPythonDump() << _this() << ".SetTopology( " << theValue << " )";
922 }
923
924 //=============================================================================
925 /*!
926  *  BLSURFPlugin_Hypothesis_i::GetTopology
927  *
928  *  Get Topology
929  */
930 //=============================================================================
931 CORBA::Long BLSURFPlugin_Hypothesis_i::GetTopology() {
932   ASSERT(myBaseImpl);
933   return this->GetImpl()->GetTopology();
934 }
935
936 //=============================================================================
937 /*!
938  *  Activate/deactivate surface proximity computation
939  */
940 void BLSURFPlugin_Hypothesis_i::SetSurfaceProximity( CORBA::Boolean toUse )
941 {
942   if ( GetSurfaceProximity() != toUse )
943   {
944     this->GetImpl()->SetUseSurfaceProximity( toUse );
945     SMESH::TPythonDump() << _this() << ".SetSurfaceProximity( " << toUse << " )";
946   }
947 }
948
949 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetSurfaceProximity()
950 {
951   return this->GetImpl()->GetUseSurfaceProximity();
952 }
953
954 //=============================================================================
955 /*!
956  * Set number of surface element layers to be generated due to surface proximity
957  */
958 void BLSURFPlugin_Hypothesis_i::SetNbSurfaceProximityLayers( CORBA::Short nbLayers )
959 {
960   if ( GetNbSurfaceProximityLayers() != nbLayers )
961   {
962     this->GetImpl()->SetNbSurfaceProximityLayers( nbLayers );
963     SMESH::TPythonDump() << _this() << ".SetNbSurfaceProximityLayers( " << nbLayers << " )";
964   }
965 }
966
967 CORBA::Short BLSURFPlugin_Hypothesis_i::GetNbSurfaceProximityLayers()
968 {
969   return (CORBA::Short) this->GetImpl()->GetNbSurfaceProximityLayers();
970 }
971
972 //=============================================================================
973 /*!
974  * Set coefficient by which size of element refined due to surface proximity is increased
975  */
976 void BLSURFPlugin_Hypothesis_i::SetSurfaceProximityRatio( CORBA::Double ratio )
977 {
978   if ( GetSurfaceProximityRatio() != ratio )
979   {
980     this->GetImpl()->SetSurfaceProximityRatio( ratio );
981     SMESH::TPythonDump() << _this() << ".SetSurfaceProximityRatio( " << ratio << " )";
982   }
983 }
984
985 CORBA::Double BLSURFPlugin_Hypothesis_i::GetSurfaceProximityRatio()
986 {
987   return this->GetImpl()->GetSurfaceProximityRatio();
988 }
989
990 //=============================================================================
991 /*!
992  *  Activate/deactivate volume proximity computation
993  */
994 void BLSURFPlugin_Hypothesis_i::SetVolumeProximity( CORBA::Boolean toUse )
995 {
996   if ( GetVolumeProximity() != toUse )
997   {
998     this->GetImpl()->SetUseVolumeProximity( toUse );
999     SMESH::TPythonDump() << _this() << ".SetVolumeProximity( " << toUse << " )";
1000   }
1001 }
1002
1003 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetVolumeProximity()
1004 {
1005   return this->GetImpl()->GetUseVolumeProximity();
1006 }
1007
1008
1009 //=============================================================================
1010 /*!
1011  * Set number of surface element layers to be generated due to volume proximity
1012  */
1013 void BLSURFPlugin_Hypothesis_i::SetNbVolumeProximityLayers( CORBA::Short nbLayers )
1014 {
1015   if ( GetNbVolumeProximityLayers() != nbLayers )
1016   {
1017     this->GetImpl()->SetNbVolumeProximityLayers( nbLayers );
1018     SMESH::TPythonDump() << _this() << ".SetNbVolumeProximityLayers( " << nbLayers << " )";
1019   }
1020 }
1021
1022 CORBA::Short BLSURFPlugin_Hypothesis_i::GetNbVolumeProximityLayers()
1023 {
1024   return (CORBA::Short) this->GetImpl()->GetNbVolumeProximityLayers();
1025 }
1026
1027 //=============================================================================
1028   /*!
1029    * Set coefficient by which size of element refined due to volume proximity is increased
1030    */
1031 void BLSURFPlugin_Hypothesis_i::SetVolumeProximityRatio( CORBA::Double ratio )
1032 {
1033   if ( GetVolumeProximityRatio() != ratio )
1034   {
1035     this->GetImpl()->SetVolumeProximityRatio( ratio );
1036     SMESH::TPythonDump() << _this() << ".SetVolumeProximityRatio( " << ratio << " )";
1037   }
1038 }
1039
1040 CORBA::Double BLSURFPlugin_Hypothesis_i::GetVolumeProximityRatio()
1041 {
1042   return this->GetImpl()->GetVolumeProximityRatio();
1043 }
1044
1045 //=============================================================================
1046 void BLSURFPlugin_Hypothesis_i::SetVerbosity(CORBA::Short theVal) {
1047   ASSERT(myBaseImpl);
1048   if (theVal < 0 || theVal > 10)
1049     THROW_SALOME_CORBA_EXCEPTION( "Invalid verbosity level",SALOME::BAD_PARAM );
1050   this->GetImpl()->SetVerbosity(theVal);
1051   SMESH::TPythonDump() << _this() << ".SetVerbosity( " << theVal << " )";
1052 }
1053
1054 //=============================================================================
1055
1056 CORBA::Short BLSURFPlugin_Hypothesis_i::GetVerbosity() {
1057   ASSERT(myBaseImpl);
1058   return (CORBA::Short) this->GetImpl()->GetVerbosity();
1059 }
1060
1061
1062 //=============================================================================
1063 void BLSURFPlugin_Hypothesis_i::SetEnforcedMeshes(const BLSURFPlugin::EnforcedMeshesList& theMeshes )
1064 {
1065   std::vector< ::BLSURFPlugin_Hypothesis::EnforcedMesh > enforcedMeshes;
1066   for ( CORBA::ULong i = 0; i < theMeshes.length(); ++i )
1067   {
1068     const BLSURFPlugin::MG_EnforcedMesh1D & inEM = theMeshes[ i ];
1069     if ( CORBA::is_nil( inEM.mesh ))
1070       THROW_SALOME_CORBA_EXCEPTION( "NULL enforced mesh",SALOME::BAD_PARAM );
1071
1072     SMESH::SMESH_Mesh_var mesh = inEM.mesh->GetMesh();
1073     if ( CORBA::is_nil( mesh ))
1074       THROW_SALOME_CORBA_EXCEPTION( "BAD enforced mesh",SALOME::BAD_PARAM );
1075
1076     int meshID = GetMeshPersistentId( mesh );
1077     if ( meshID < 0 )
1078       THROW_SALOME_CORBA_EXCEPTION( "BAD enforced mesh",SALOME::BAD_PARAM );
1079
1080     bool isGroup = false;
1081     int   partID = GetMeshPartPersistentId( inEM.mesh, isGroup );
1082     ::EnforcedMeshType partType = ENFORCED_MESH;
1083     if ( partID > -1 )
1084       partType = isGroup ? ENFORCED_GROUP : ENFORCED_SUBMESH;
1085
1086     enforcedMeshes.push_back({ meshID, partID, partType, inEM.groupName.in() });
1087   }
1088
1089   if ( GetImpl()->GetEnforcedMeshes() == enforcedMeshes )
1090     return;
1091
1092   this->GetImpl()->SetEnforcedMeshes( enforcedMeshes );
1093
1094   // dump
1095
1096   SMESH::TPythonDump pyDump;
1097   pyDump << BLSURFPlugin::BLSURFPlugin_Hypothesis_var( _this() )
1098          << ".SetEnforcedMeshes([ ";
1099
1100   for ( CORBA::ULong i = 0; i < theMeshes.length(); ++i )
1101   {
1102     const BLSURFPlugin::MG_EnforcedMesh1D & inEM = theMeshes[ i ];
1103     pyDump << "BLSURFPlugin.MG_EnforcedMesh1D( " << inEM.mesh.in() << ", ";
1104     if ( inEM.groupName.in() && inEM.groupName.in()[0] )
1105       pyDump << "'" << inEM.groupName.in() << "'";
1106     else
1107       pyDump << "''";
1108     pyDump << ")" << ( i + 1 < theMeshes.length() ? ", " : "");
1109   }
1110   pyDump << "])";
1111 }
1112
1113 //=============================================================================
1114
1115 BLSURFPlugin::EnforcedMeshesList* BLSURFPlugin_Hypothesis_i::GetEnforcedMeshes()
1116 {
1117   const std::vector< ::BLSURFPlugin_Hypothesis::EnforcedMesh > & hypEnfMeshes =
1118     this->GetImpl()->GetEnforcedMeshes();
1119
1120   BLSURFPlugin::EnforcedMeshesList_var outEnfMeshes = new BLSURFPlugin::EnforcedMeshesList();
1121   outEnfMeshes->length( hypEnfMeshes.size() );
1122
1123   int nbMeshes = 0;
1124   for ( size_t i = 0; i < hypEnfMeshes.size(); ++i )
1125   {
1126     const ::BLSURFPlugin_Hypothesis::EnforcedMesh& enfMeshData = hypEnfMeshes[ i ];
1127     BLSURFPlugin::MG_EnforcedMesh1D &               outEnfMesh = outEnfMeshes[ nbMeshes ];
1128
1129     SMESH::SMESH_Mesh_var mesh = FindMeshByID( enfMeshData._meshID );
1130     switch ( enfMeshData._type ) {
1131     case ENFORCED_MESH   :
1132     {
1133       outEnfMesh.mesh = SMESH::SMESH_IDSource::_narrow( mesh );
1134       break;
1135     }
1136     case ENFORCED_GROUP  :
1137     {
1138       SMESH::SMESH_GroupBase_var group = GetGroupByID( mesh, enfMeshData._subID );
1139       outEnfMesh.mesh = SMESH::SMESH_IDSource::_narrow( group );
1140       break;
1141     }
1142     case ENFORCED_SUBMESH:
1143     {
1144       SMESH::SMESH_subMesh_var subMesh;
1145       subMesh   = GetSubMeshByID( mesh, enfMeshData._subID, SMESH::Tag_SubMeshOnEdge );
1146       if ( CORBA::is_nil( subMesh ))
1147         subMesh = GetSubMeshByID( mesh, enfMeshData._subID, SMESH::Tag_SubMeshOnCompound );
1148
1149       outEnfMesh.mesh = SMESH::SMESH_IDSource::_narrow( subMesh );
1150       break;
1151     }
1152     default: continue;
1153     }
1154     outEnfMesh.groupName = enfMeshData._groupName.c_str();
1155
1156     nbMeshes += ( !CORBA::is_nil( outEnfMesh.mesh ));
1157   }
1158   outEnfMeshes->length( nbMeshes );
1159
1160   return outEnfMeshes._retn();
1161 }
1162
1163 //=============================================================================
1164 void BLSURFPlugin_Hypothesis_i::SetEnforceCadEdgesSize( CORBA::Boolean toEnforce )
1165 {
1166   if ( GetEnforceCadEdgesSize() != toEnforce )
1167   {
1168     this->GetImpl()->SetEnforceCadEdgesSize(toEnforce);
1169     SMESH::TPythonDump() << _this() << ".SetEnforceCadEdgesSize( " << toEnforce << " )";
1170   }
1171 }
1172 //=============================================================================
1173 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetEnforceCadEdgesSize()
1174 {
1175   return this->GetImpl()->GetEnforceCadEdgesSize();
1176 }
1177 //=============================================================================
1178
1179 void BLSURFPlugin_Hypothesis_i::SetJacobianRectificationRespectGeometry( CORBA::Boolean allowRectification )
1180 {
1181   if ( GetJacobianRectificationRespectGeometry() != allowRectification )
1182   {
1183     this->GetImpl()->SetJacobianRectificationRespectGeometry(allowRectification);
1184     SMESH::TPythonDump() << _this() << ".SetJacobianRectificationRespectGeometry( " << allowRectification << " )";
1185   }
1186 }
1187 //=============================================================================
1188 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetJacobianRectificationRespectGeometry()
1189 {
1190   return this->GetImpl()->GetJacobianRectificationRespectGeometry();
1191 }
1192 //=============================================================================
1193
1194 void BLSURFPlugin_Hypothesis_i::SetJacobianRectification( CORBA::Boolean allowRectification )
1195 {
1196   if ( GetJacobianRectification() != allowRectification )
1197   {
1198     this->GetImpl()->SetJacobianRectification(allowRectification);
1199     SMESH::TPythonDump() << _this() << ".SetJacobianRectification( " << allowRectification << " )";
1200   }
1201 }
1202 //=============================================================================
1203 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetJacobianRectification()
1204 {
1205   return this->GetImpl()->GetJacobianRectification();
1206 }
1207 //=============================================================================
1208
1209 void BLSURFPlugin_Hypothesis_i::SetUseDeprecatedPatchMesher( CORBA::Boolean useDeprecatedPatchMesher )
1210 {
1211   if ( GetUseDeprecatedPatchMesher() != useDeprecatedPatchMesher )
1212   {
1213     this->GetImpl()->SetUseDeprecatedPatchMesher(useDeprecatedPatchMesher);
1214     SMESH::TPythonDump() << _this() << ".SetUseDeprecatedPatchMesher( " << useDeprecatedPatchMesher << " )";
1215   }
1216 }
1217 //=============================================================================
1218 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseDeprecatedPatchMesher()
1219 {
1220   return this->GetImpl()->GetUseDeprecatedPatchMesher();
1221 }
1222 //=============================================================================
1223
1224 void BLSURFPlugin_Hypothesis_i::SetMaxNumberOfPointsPerPatch( CORBA::Long nb )
1225 {
1226   if ( GetMaxNumberOfPointsPerPatch() != nb )
1227   {
1228     try {
1229       this->GetImpl()->SetMaxNumberOfPointsPerPatch(nb);
1230
1231     } catch (const std::invalid_argument& ex) {
1232       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1233     } catch (SALOME_Exception& ex) {
1234       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1235     }
1236     SMESH::TPythonDump() << _this() << ".SetMaxNumberOfPointsPerPatch( " << nb << " )";
1237   }
1238 }
1239 //=============================================================================
1240 CORBA::Long BLSURFPlugin_Hypothesis_i::GetMaxNumberOfPointsPerPatch()
1241 {
1242   return this->GetImpl()->GetMaxNumberOfPointsPerPatch();
1243 }
1244 //=============================================================================
1245
1246 void BLSURFPlugin_Hypothesis_i::SetMaxNumberOfThreads( CORBA::Long nb )
1247 {
1248   if ( GetMaxNumberOfThreads() != nb )
1249   {
1250     try {
1251       this->GetImpl()->SetMaxNumberOfThreads(nb);
1252
1253     } catch (const std::invalid_argument& ex) {
1254       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1255     } catch (SALOME_Exception& ex) {
1256       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1257     }
1258     SMESH::TPythonDump() << _this() << ".SetMaxNumberOfThreads( " << nb << " )";
1259   }
1260 }
1261 //=============================================================================
1262 CORBA::Long BLSURFPlugin_Hypothesis_i::GetMaxNumberOfThreads()
1263 {
1264   return this->GetImpl()->GetMaxNumberOfThreads();
1265 }
1266 //=============================================================================
1267
1268 void BLSURFPlugin_Hypothesis_i::SetRespectGeometry( CORBA::Boolean toRespect )
1269 {
1270   if ( GetRespectGeometry() != toRespect )
1271   {
1272     this->GetImpl()->SetRespectGeometry(toRespect);
1273     SMESH::TPythonDump() << _this() << ".SetRespectGeometry( " << toRespect << " )";
1274   }
1275 }
1276 //=============================================================================
1277 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetRespectGeometry()
1278 {
1279   return this->GetImpl()->GetRespectGeometry();
1280 }
1281 //=============================================================================
1282
1283 void BLSURFPlugin_Hypothesis_i::SetTinyEdgesAvoidSurfaceIntersections( CORBA::Boolean toAvoidIntersection )
1284 {
1285   if ( GetTinyEdgesAvoidSurfaceIntersections() != toAvoidIntersection )
1286   {
1287     this->GetImpl()->SetTinyEdgesAvoidSurfaceIntersections(toAvoidIntersection);
1288     SMESH::TPythonDump() << _this() << ".SetTinyEdgesAvoidSurfaceIntersections( " << toAvoidIntersection << " )";
1289   }
1290 }
1291 //=============================================================================
1292 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetTinyEdgesAvoidSurfaceIntersections()
1293 {
1294   return this->GetImpl()->GetTinyEdgesAvoidSurfaceIntersections();
1295 }
1296 //=============================================================================
1297
1298 void BLSURFPlugin_Hypothesis_i::SetClosedGeometry( CORBA::Boolean isClosed )
1299 {
1300   if ( GetClosedGeometry() != isClosed )
1301   {
1302     this->GetImpl()->SetClosedGeometry(isClosed);
1303     SMESH::TPythonDump() << _this() << ".SetClosedGeometry( " << isClosed << " )";
1304   }
1305 }
1306 //=============================================================================
1307 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetClosedGeometry()
1308 {
1309   return this->GetImpl()->GetClosedGeometry();
1310 }
1311 //=============================================================================
1312
1313 void BLSURFPlugin_Hypothesis_i::SetDebug( CORBA::Boolean isDebug )
1314 {
1315   if ( GetDebug() != isDebug )
1316   {
1317     this->GetImpl()->SetDebug(isDebug);
1318     SMESH::TPythonDump() << _this() << ".SetDebug( " << isDebug << " )";
1319   }
1320 }
1321 //=============================================================================
1322 bool BLSURFPlugin_Hypothesis_i::GetDebug()
1323 {
1324   return this->GetImpl()->GetDebug();
1325 }
1326 //=============================================================================
1327
1328 void BLSURFPlugin_Hypothesis_i::SetPeriodicTolerance( CORBA::Double tol )
1329 {
1330   bool isDefault;
1331   if ( GetImpl()->GetPreCADOptionValue("periodic_tolerance",&isDefault) != SMESH_Comment( tol ))
1332   {
1333     try
1334     {
1335       this->GetImpl()->SetPeriodicTolerance(tol);
1336
1337     } catch (const std::invalid_argument& ex) {
1338       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1339     } catch (SALOME_Exception& ex) {
1340       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1341     }
1342     SMESH::TPythonDump() << _this() << ".SetPeriodicTolerance( " << tol << " )";
1343   }
1344 }
1345 //=============================================================================
1346 double BLSURFPlugin_Hypothesis_i::GetPeriodicTolerance()
1347 {
1348   try{
1349     return this->GetImpl()->GetPeriodicTolerance();
1350
1351   } catch (const std::invalid_argument& ex) {
1352     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1353   } catch (SALOME_Exception& ex) {
1354     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1355   }
1356   return -1;
1357 }
1358 //=============================================================================
1359
1360 void BLSURFPlugin_Hypothesis_i::SetRequiredEntities( const char* howToTreat )
1361 {
1362   if ( GetImpl()->GetRequiredEntities() != howToTreat )
1363   {
1364     try {
1365       this->GetImpl()->SetRequiredEntities(howToTreat);
1366
1367     } catch (const std::invalid_argument& ex) {
1368       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1369     } catch (SALOME_Exception& ex) {
1370       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1371     }
1372     SMESH::TPythonDump() << _this() << ".SetRequiredEntities( '" << howToTreat << "' )";
1373   }
1374 }
1375 //=============================================================================
1376 char* BLSURFPlugin_Hypothesis_i::GetRequiredEntities()
1377 {
1378   return CORBA::string_dup( this->GetImpl()->GetRequiredEntities().c_str() );
1379 }
1380 //=============================================================================
1381
1382 void BLSURFPlugin_Hypothesis_i::SetSewingTolerance( CORBA::Double tol )
1383 {
1384   bool isDefault;
1385   if ( GetImpl()->GetPreCADOptionValue("sewing_tolerance",&isDefault) != SMESH_Comment( tol ))
1386   {
1387     try
1388     {
1389       this->GetImpl()->SetSewingTolerance(tol);
1390       SMESH::TPythonDump() << _this() << ".SetSewingTolerance( " << tol << " )";
1391
1392     } catch (const std::invalid_argument& ex) {
1393       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1394     } catch (SALOME_Exception& ex) {
1395       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1396     }
1397   }
1398 }
1399 //=============================================================================
1400 CORBA::Double BLSURFPlugin_Hypothesis_i::GetSewingTolerance()
1401 {
1402   try
1403   {
1404     return this->GetImpl()->GetSewingTolerance();
1405
1406   } catch (const std::invalid_argument& ex) {
1407     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1408   } catch (SALOME_Exception& ex) {
1409     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1410   }
1411   return -1;
1412 }
1413 //=============================================================================
1414
1415 void BLSURFPlugin_Hypothesis_i::SetTags( const char* howToTreat )
1416 {
1417   if ( GetImpl()->GetTags() != howToTreat )
1418   {
1419     try {
1420       this->GetImpl()->SetTags(howToTreat);
1421     }
1422     catch (const std::invalid_argument& ex) {
1423       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1424     } catch (SALOME_Exception& ex) {
1425       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1426     }
1427   }
1428   SMESH::TPythonDump() << _this() << ".SetTags( '" << howToTreat << "' )";
1429 }
1430 //=============================================================================
1431 char* BLSURFPlugin_Hypothesis_i::GetTags()
1432 {
1433   return CORBA::string_dup( this->GetImpl()->GetTags().c_str() );
1434 }
1435
1436 //=============================================================================
1437 void BLSURFPlugin_Hypothesis_i::SetHyperPatches(const BLSURFPlugin::THyperPatchList& hpl)
1438 {
1439   ::BLSURFPlugin_Hypothesis::THyperPatchList patchList( hpl.length() );
1440   SMESH_Comment hplDump;
1441   hplDump << "[";
1442   for ( CORBA::ULong i = 0; i < patchList.size(); ++i )
1443   {
1444     hplDump << "[ ";
1445     BLSURFPlugin::THyperPatch tags = hpl[ i ];
1446     for ( CORBA::ULong j = 0; j < tags.length(); ++j )
1447     {
1448       patchList[ i ].insert( tags[ j ]);
1449       hplDump << tags[ j ] << ( j+1 < tags.length() ? ", " : " ]" );
1450     }
1451     hplDump << ( i+1 < patchList.size() ? "," : "]");
1452   }
1453   if ( GetImpl()->GetHyperPatches() != patchList )
1454   {
1455     GetImpl()->SetHyperPatches( ::BLSURFPlugin_Hypothesis::THyperPatchEntriesList() ); // erase entries
1456     GetImpl()->SetHyperPatches( patchList );
1457     SMESH::TPythonDump() << _this() << ".SetHyperPatches( " << hplDump << " )";
1458   }
1459 }
1460
1461 //=============================================================================
1462 void BLSURFPlugin_Hypothesis_i::SetHyperPatchEntries(const BLSURFPlugin::THyperPatchEntriesList& hpe)
1463 {
1464   ::BLSURFPlugin_Hypothesis::THyperPatchEntriesList patchList( hpe.length() );
1465   SMESH_Comment hpeDump;
1466   hpeDump << "[";
1467   for ( CORBA::ULong i = 0; i < patchList.size(); ++i )
1468   {
1469     hpeDump << "[ ";
1470     const BLSURFPlugin::THyperPatchEntries& entryList = hpe[ i ];
1471     for ( CORBA::ULong j = 0; j < entryList.length(); ++j )
1472     {
1473       patchList[ i ].insert( entryList[ j ].in() );
1474       hpeDump << entryList[ j ].in() << ( j+1 < entryList.length() ? ", " : " ]" );
1475     }
1476     hpeDump << ( i+1 < patchList.size() ? "," : "]");
1477   }
1478   if ( GetImpl()->GetHyperPatchEntries() != patchList )
1479   {
1480     GetImpl()->SetHyperPatches( ::BLSURFPlugin_Hypothesis::THyperPatchList(), /*notify=*/false );
1481     GetImpl()->SetHyperPatches( patchList );
1482     // TPythonDump converts entries to objects
1483     SMESH::TPythonDump() << _this() << ".SetHyperPatchShapes( " << hpeDump << " )";
1484   }
1485 }
1486
1487 //=============================================================================
1488 void BLSURFPlugin_Hypothesis_i::SetHyperPatchShapes(const BLSURFPlugin::THyperPatchShapesList& hpsl)
1489 {
1490   BLSURFPlugin::THyperPatchEntriesList patchList;
1491   patchList.length( hpsl.length() );
1492   for ( CORBA::ULong i = 0; i < hpsl.length(); ++i )
1493   {
1494     const GEOM::ListOfGO&             shapeList = hpsl[ i ];
1495     BLSURFPlugin::THyperPatchEntries& entryList = patchList[ i ];
1496     entryList.length( shapeList.length() );
1497     for ( CORBA::ULong j = 0; j < shapeList.length(); ++j )
1498     {
1499       CORBA::String_var entry = shapeList[ j ]->GetStudyEntry();
1500       if ( !entry.in() || !entry.in()[0] )
1501         THROW_SALOME_CORBA_EXCEPTION( "BLSURFPlugin_Hypothesis::SetHyperPatchShapes(), "
1502                                       "Not published hyper-patch shape", SALOME::BAD_PARAM );
1503       entryList[ j ] = CORBA::string_dup( entry );
1504     }
1505   }
1506   this->SetHyperPatchEntries( patchList );
1507 }
1508
1509 //=============================================================================
1510 BLSURFPlugin::THyperPatchList*
1511 BLSURFPlugin_Hypothesis_i::GetHyperPatches( GEOM::GEOM_Object_ptr mainShape )
1512 {
1513   const ::BLSURFPlugin_Hypothesis::THyperPatchList& hpl = GetImpl()->GetHyperPatches();
1514   BLSURFPlugin::THyperPatchList*                 resHpl = new BLSURFPlugin::THyperPatchList();
1515   if ( hpl.empty() &&
1516        !CORBA::is_nil( mainShape ) &&
1517        !GetImpl()->GetHyperPatchEntries().empty() )
1518   {
1519     // set IDs by entries
1520     SMESH_Gen_i* smeshGen = SMESH_Gen_i::GetSMESHGen();
1521     TopoDS_Shape S = smeshGen->GeomObjectToShape( mainShape );
1522     if ( !S.IsNull() )
1523     {
1524       std::map< std::string, TopoDS_Shape > entryToShape;
1525       BLSURFPlugin_BLSURF::FillEntryToShape( GetImpl(), entryToShape );
1526       GetImpl()->SetHyperPatchIDsByEntry( S, entryToShape );
1527     }
1528   }
1529   resHpl->length((CORBA::ULong) hpl.size() );
1530
1531   ::BLSURFPlugin_Hypothesis::THyperPatchList::const_iterator hpIt = hpl.begin();
1532   for ( int i = 0; hpIt != hpl.end(); ++hpIt, ++i )
1533   {
1534     const ::BLSURFPlugin_Hypothesis::THyperPatchTags& hp = *hpIt;
1535     BLSURFPlugin::THyperPatch& resHp = (*resHpl)[ i ];
1536     resHp.length((CORBA::ULong) hp.size() );
1537
1538     ::BLSURFPlugin_Hypothesis::THyperPatchTags::const_iterator tag = hp.begin();
1539     for ( int j = 0; tag != hp.end(); ++tag, ++j )
1540       resHp[ j ] = *tag;
1541   }
1542   return resHpl;
1543 }
1544
1545 //=============================================================================
1546 BLSURFPlugin::THyperPatchEntriesList* BLSURFPlugin_Hypothesis_i::GetHyperPatchShapes()
1547 {
1548   const ::BLSURFPlugin_Hypothesis::THyperPatchEntriesList& hpel = GetImpl()->GetHyperPatchEntries();
1549   BLSURFPlugin::THyperPatchEntriesList* resHpl = new BLSURFPlugin::THyperPatchEntriesList();
1550   resHpl->length((CORBA::ULong) hpel.size() );
1551
1552   ::BLSURFPlugin_Hypothesis::THyperPatchEntriesList::const_iterator hpIt = hpel.begin();
1553   for ( int i = 0; hpIt != hpel.end(); ++hpIt, ++i )
1554   {
1555     const ::BLSURFPlugin_Hypothesis::THyperPatchEntries& hp = *hpIt;
1556     BLSURFPlugin::THyperPatchEntries& resHp = (*resHpl)[ i ];
1557     resHp.length((CORBA::ULong) hp.size() );
1558
1559     ::BLSURFPlugin_Hypothesis::THyperPatchEntries::const_iterator entry = hp.begin();
1560     for ( int j = 0; entry != hp.end(); ++entry, ++j )
1561       resHp[ j ] = CORBA::string_dup( entry->c_str() );
1562   }
1563   return resHpl;
1564 }
1565
1566 //=============================================================================
1567 /*!
1568  *  BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges
1569  *
1570  *  Set true or false
1571  */
1572 //=============================================================================
1573 void BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges(CORBA::Boolean theValue) {
1574   ASSERT(myBaseImpl);
1575   this->GetImpl()->SetPreCADMergeEdges(theValue);
1576   std::string theValueStr = theValue ? "True" : "False";
1577   SMESH::TPythonDump() << _this() << ".SetPreCADMergeEdges( " << theValueStr.c_str() << " )";
1578 }
1579
1580 //=============================================================================
1581 /*!
1582  *  BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges
1583  *
1584  *  Get true or false
1585  */
1586 //=============================================================================
1587 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges() {
1588   ASSERT(myBaseImpl);
1589   return this->GetImpl()->GetPreCADMergeEdges();
1590 }
1591
1592 //=============================================================================
1593 /*!
1594  *  BLSURFPlugin_Hypothesis_i::SetPreCADRemoveDuplicateCADFaces
1595  *
1596  *  Set true or false
1597  */
1598 //=============================================================================
1599 void BLSURFPlugin_Hypothesis_i::SetPreCADRemoveDuplicateCADFaces(CORBA::Boolean theValue) {
1600   ASSERT(myBaseImpl);
1601   this->GetImpl()->SetPreCADRemoveDuplicateCADFaces(theValue);
1602   std::string theValueStr = theValue ? "True" : "False";
1603   SMESH::TPythonDump() << _this() << ".SetPreCADRemoveDuplicateCADFaces( " << theValueStr.c_str() << " )";
1604 }
1605
1606 //=============================================================================
1607 /*!
1608  *  BLSURFPlugin_Hypothesis_i::GetPreCADRemoveDuplicateCADFaces
1609  *
1610  *  Get true or false
1611  */
1612 //=============================================================================
1613 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADRemoveDuplicateCADFaces() {
1614   ASSERT(myBaseImpl);
1615   return this->GetImpl()->GetPreCADRemoveDuplicateCADFaces();
1616 }
1617
1618 //=============================================================================
1619 /*!
1620  *  BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology
1621  *
1622  *  Set true or false
1623  */
1624 //=============================================================================
1625 void BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology(CORBA::Boolean theValue) {
1626   ASSERT(myBaseImpl);
1627   this->GetImpl()->SetPreCADProcess3DTopology(theValue);
1628   std::string theValueStr = theValue ? "True" : "False";
1629   SMESH::TPythonDump() << _this() << ".SetPreCADProcess3DTopology( " << theValueStr.c_str() << " )";
1630 }
1631
1632 //=============================================================================
1633 /*!
1634  *  BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology
1635  *
1636  *  Get true or false
1637  */
1638 //=============================================================================
1639 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology() {
1640   ASSERT(myBaseImpl);
1641   return this->GetImpl()->GetPreCADProcess3DTopology();
1642 }
1643
1644 //=============================================================================
1645 /*!
1646  *  BLSURFPlugin_Hypothesis_i::SetPreCADDiscardInput
1647  *
1648  *  Set true or false
1649  */
1650 //=============================================================================
1651 void BLSURFPlugin_Hypothesis_i::SetPreCADDiscardInput(CORBA::Boolean theValue) {
1652   ASSERT(myBaseImpl);
1653   this->GetImpl()->SetPreCADDiscardInput(theValue);
1654   std::string theValueStr = theValue ? "True" : "False";
1655   SMESH::TPythonDump() << _this() << ".SetPreCADDiscardInput( " << theValueStr.c_str() << " )";
1656 }
1657
1658 //=============================================================================
1659 /*!
1660  *  BLSURFPlugin_Hypothesis_i::GetPreCADDiscardInput
1661  *
1662  *  Get true or false
1663  */
1664 //=============================================================================
1665 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADDiscardInput() {
1666   ASSERT(myBaseImpl);
1667   return this->GetImpl()->GetPreCADDiscardInput();
1668 }
1669
1670
1671 //=============================================================================
1672
1673 void BLSURFPlugin_Hypothesis_i::SetOptionValue(const char* optionName, const char* optionValue)
1674 {
1675   ASSERT(myBaseImpl);
1676   try {
1677     std::string name( optionName );
1678     if ( !optionValue || !optionValue[0] )
1679       UnsetOption( optionName );
1680
1681     // basic options (visible in Advanced table)
1682
1683     else if ( name == "enforce_cad_edge_sizes" )
1684       SetEnforceCadEdgesSize( GetImpl()->ToBool( optionValue ));
1685
1686     else if ( name == "jacobian_rectification_respect_geometry" )
1687       SetJacobianRectificationRespectGeometry( GetImpl()->ToBool( optionValue ));
1688
1689     else if ( name == "max_number_of_points_per_patch" )
1690       SetMaxNumberOfPointsPerPatch( GetImpl()->ToInt( optionValue ));
1691
1692     else if ( name == "max_number_of_threads" )
1693       SetMaxNumberOfThreads( GetImpl()->ToInt( optionValue ));
1694
1695     else if ( name == "rectify_jacobian" )
1696       SetJacobianRectification( GetImpl()->ToBool( optionValue ));
1697
1698     else if ( name == "use_deprecated_patch_mesher" )
1699       SetUseDeprecatedPatchMesher( GetImpl()->ToBool( optionValue ));
1700
1701     else if ( name == "respect_geometry" )
1702       SetRespectGeometry( GetImpl()->ToBool( optionValue ));
1703
1704     else if ( name == "tiny_edge_avoid_surface_intersections" )
1705       SetTinyEdgesAvoidSurfaceIntersections( GetImpl()->ToBool( optionValue ));
1706
1707     else if ( name == "closed_geometry" )
1708       SetClosedGeometry( GetImpl()->ToBool( optionValue ));
1709
1710     else if ( name == "debug" )
1711       SetDebug( GetImpl()->ToBool( optionValue ));
1712
1713     else if ( name == "discard_input_topology" )
1714       SetPreCADDiscardInput( GetImpl()->ToBool( optionValue ));
1715
1716     else if ( name == "merge_edges" )
1717       SetPreCADMergeEdges( GetImpl()->ToBool( optionValue ));
1718
1719     else if ( name == "periodic_tolerance" )
1720       SetPeriodicTolerance( GetImpl()->ToDbl( optionValue ));
1721
1722     else if ( name == "remove_duplicate_cad_faces" )
1723       SetPreCADRemoveDuplicateCADFaces( GetImpl()->ToBool( optionValue ));
1724
1725     else if ( name == "required_entities" )
1726       SetRequiredEntities( optionValue );
1727
1728     else if ( name == "sewing_tolerance" )
1729       SetSewingTolerance( GetImpl()->ToDbl( optionValue ));
1730
1731     else if ( name == "tags" )
1732       SetTags( optionValue );
1733
1734     // other basic options with specific methods
1735
1736     else if ( name == "correct_surface_intersections" )
1737       SetCorrectSurfaceIntersection( GetImpl()->ToBool( optionValue ));
1738
1739     else if ( name == "optimise_tiny_edges" )
1740       SetOptimiseTinyEdges( GetImpl()->ToBool( optionValue ));
1741
1742     else if ( name == "surface_intersections_processing_max_cost" )
1743       SetCorrectSurfaceIntersectionMaxCost( GetImpl()->ToDbl( optionValue ));
1744
1745     else if ( name == "volume_gradation" )
1746       SetVolumeGradation( GetImpl()->ToDbl( optionValue ));
1747
1748     else if ( name == "tiny_edge_optimisation_length" )
1749       SetTinyEdgeOptimisationLength( GetImpl()->ToDbl( optionValue ));
1750
1751     else if ( name == "proximity" )
1752       SetVolumeProximity( GetImpl()->ToBool( optionValue ));
1753
1754     else if ( name == "prox_ratio" )
1755       SetVolumeProximityRatio( GetImpl()->ToDbl( optionValue ));
1756
1757     else if ( name == "prox_nb_layer" )
1758       SetNbVolumeProximityLayers((CORBA::Short) GetImpl()->ToInt( optionValue ));
1759
1760     // advanced options (for backward compatibility)
1761
1762     else if ( name == "create_tag_on_collision" ||
1763               name == "tiny_edge_respect_geometry" )
1764       AddOption( optionName, optionValue );
1765
1766     else {
1767       bool valueChanged;
1768       valueChanged = ( this->GetImpl()->GetOptionValue( name ) != optionValue &&
1769                        this->GetImpl()->GetOptionValue( name, &valueChanged ) != optionValue );
1770       if ( valueChanged )
1771       {
1772         this->GetImpl()->SetOptionValue(optionName, optionValue);
1773         SMESH::TPythonDump() << _this() << ".SetOptionValue( '" << optionName << "', '" << optionValue << "' )";
1774       }
1775     }
1776   } catch (const std::invalid_argument& ex) {
1777     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1778   } catch (SALOME_Exception& ex) {
1779     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1780   }
1781 }
1782
1783 //=============================================================================
1784
1785 void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValue(const char* optionName, const char* optionValue)
1786 {
1787   ASSERT(myBaseImpl);
1788   bool valueChanged = false;
1789   try {
1790     std::string name( optionName );
1791     if ( !optionValue || !optionValue[0] )
1792       UnsetOption( optionName );
1793
1794     else if ( name == "closed_geometry" )
1795       SetClosedGeometry( GetImpl()->ToBool( optionValue ));
1796
1797     else if ( name == "debug" )
1798       SetDebug( GetImpl()->ToBool( optionValue ));
1799
1800     else if ( name == "discard_input_topology" )
1801       SetPreCADDiscardInput( GetImpl()->ToBool( optionValue ));
1802
1803     else if ( name == "merge_edges" )
1804       SetPreCADMergeEdges( GetImpl()->ToBool( optionValue ));
1805
1806     else if ( name == "periodic_tolerance" )
1807       SetPeriodicTolerance( GetImpl()->ToDbl( optionValue ));
1808
1809     else if ( name == "remove_duplicate_cad_faces" )
1810       SetPreCADRemoveDuplicateCADFaces( GetImpl()->ToBool( optionValue ));
1811
1812     else if ( name == "required_entities" )
1813       SetRequiredEntities( optionValue );
1814
1815     else if ( name == "sewing_tolerance" )
1816       SetSewingTolerance( GetImpl()->ToDbl( optionValue ));
1817
1818     else if ( name == "tags" )
1819       SetTags( optionValue );
1820
1821     // other basic options with specific methods
1822
1823     else if ( name == "correct_surface_intersections" )
1824       SetCorrectSurfaceIntersection( GetImpl()->ToBool( optionValue ));
1825
1826     else if ( name == "optimise_tiny_edges" )
1827       SetOptimiseTinyEdges( GetImpl()->ToBool( optionValue ));
1828
1829     else if ( name == "surface_intersections_processing_max_cost" )
1830       SetCorrectSurfaceIntersectionMaxCost( GetImpl()->ToDbl( optionValue ));
1831
1832     else if ( name == "volume_gradation" )
1833       SetVolumeGradation( GetImpl()->ToDbl( optionValue ));
1834
1835     else if ( name == "tiny_edge_optimisation_length" )
1836       SetTinyEdgeOptimisationLength( GetImpl()->ToDbl( optionValue ));
1837
1838     else if ( name == "process_3d_topology" )
1839       SetPreCADProcess3DTopology( GetImpl()->ToBool( optionValue ));
1840
1841     // advanced options (for backward compatibility)
1842
1843     else if ( name == "create_tag_on_collision" ||
1844               name == "tiny_edge_respect_geometry" ||
1845               name == "remove_tiny_edges" ||
1846               name == "tiny_edge_length")
1847       AddPreCADOption( optionName, optionValue );
1848
1849     else {
1850       valueChanged = (this->GetImpl()->GetPreCADOptionValue(optionName) != optionValue);
1851       if (valueChanged)
1852         this->GetImpl()->SetPreCADOptionValue(optionName, optionValue);
1853     }
1854   } catch (const std::invalid_argument& ex) {
1855     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1856   } catch (SALOME_Exception& ex) {
1857     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1858   }
1859   if (valueChanged)
1860     SMESH::TPythonDump() << _this() << ".SetPreCADOptionValue( '" << optionName << "', '" << optionValue << "' )";
1861 }
1862
1863 //=============================================================================
1864
1865 char* BLSURFPlugin_Hypothesis_i::GetOptionValue(const char* optionName) {
1866   ASSERT(myBaseImpl);
1867   try {
1868     bool isDefault;
1869     return CORBA::string_dup(this->GetImpl()->GetOptionValue(optionName,&isDefault).c_str());
1870   } catch (const std::invalid_argument& ex) {
1871     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1872   } catch (SALOME_Exception& ex) {
1873     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1874   }
1875   return 0;
1876 }
1877
1878 //=============================================================================
1879
1880 char* BLSURFPlugin_Hypothesis_i::GetPreCADOptionValue(const char* optionName) {
1881   ASSERT(myBaseImpl);
1882   try {
1883     bool isDefault;
1884     return CORBA::string_dup(this->GetImpl()->GetPreCADOptionValue(optionName,&isDefault).c_str());
1885   } catch (const std::invalid_argument& ex) {
1886     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1887   } catch (SALOME_Exception& ex) {
1888     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1889   }
1890   return 0;
1891 }
1892
1893 //=============================================================================
1894
1895 void BLSURFPlugin_Hypothesis_i::UnsetOption(const char* optionName) {
1896   ASSERT(myBaseImpl);
1897   if ( !GetImpl()->GetOptionValue( optionName ).empty() )
1898   {
1899     this->GetImpl()->ClearOption(optionName);
1900     SMESH::TPythonDump() << _this() << ".UnsetOption( '" << optionName << "' )";
1901   }
1902 }
1903
1904 //=============================================================================
1905
1906 void BLSURFPlugin_Hypothesis_i::UnsetPreCADOption(const char* optionName) {
1907   ASSERT(myBaseImpl);
1908   if ( !GetImpl()->GetPreCADOptionValue( optionName ).empty() )
1909   {
1910     this->GetImpl()->ClearPreCADOption(optionName);
1911     SMESH::TPythonDump() << _this() << ".UnsetPreCADOption( '" << optionName << "' )";
1912   }
1913 }
1914
1915 //=============================================================================
1916
1917 BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetOptionValues() {
1918   ASSERT(myBaseImpl);
1919   BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array();
1920
1921   const ::BLSURFPlugin_Hypothesis::TOptionValues & opts = this->GetImpl()->GetOptionValues();
1922   result->length((CORBA::ULong) opts.size());
1923   int i=0;
1924
1925   bool isDefault;
1926   ::BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt = opts.begin();
1927   for (; opIt != opts.end(); ++opIt, ++i) {
1928     string name_value_type = opIt->first;
1929     if (!opIt->second.empty()) {
1930       name_value_type += ":";
1931       name_value_type += GetImpl()->GetOptionValue( opIt->first, &isDefault );
1932       name_value_type += isDefault ? ":0" : ":1";
1933     }
1934     result[i] = CORBA::string_dup(name_value_type.c_str());
1935   }
1936
1937   return result._retn();
1938 }
1939
1940 //=============================================================================
1941
1942 BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetPreCADOptionValues() {
1943   ASSERT(myBaseImpl);
1944   BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array();
1945
1946   const ::BLSURFPlugin_Hypothesis::TOptionValues & opts = this->GetImpl()->GetPreCADOptionValues();
1947   result->length((CORBA::ULong) opts.size());
1948   int i=0;
1949
1950   bool isDefault;
1951   ::BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt = opts.begin();
1952   for (; opIt != opts.end(); ++opIt, ++i) {
1953     string name_value_type = opIt->first;
1954     if (!opIt->second.empty()) {
1955       name_value_type += ":";
1956       name_value_type += GetImpl()->GetPreCADOptionValue( opIt->first, &isDefault );
1957       name_value_type += isDefault ? ":0" : ":1";
1958     }
1959     result[i] = CORBA::string_dup(name_value_type.c_str());
1960   }
1961   return result._retn();
1962 }
1963
1964 //=============================================================================
1965
1966 BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetAdvancedOptionValues()
1967 {
1968   BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array();
1969
1970   const ::BLSURFPlugin_Hypothesis::TOptionValues & custom_opts = this->GetImpl()->GetCustomOptionValues();
1971   result->length((CORBA::ULong) custom_opts.size());
1972   int i=0;
1973
1974   ::BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt = custom_opts.begin();
1975   for (; opIt != custom_opts.end(); ++opIt, ++i) {
1976     string name_value_type = opIt->first;
1977     if (!opIt->second.empty()) {
1978       name_value_type += ":";
1979       name_value_type += opIt->second;
1980       name_value_type += ":1"; // user defined
1981     }
1982     result[i] = CORBA::string_dup(name_value_type.c_str());
1983   }
1984   return result._retn();
1985 }
1986
1987 //=============================================================================
1988
1989 void BLSURFPlugin_Hypothesis_i::SetOptionValues(const BLSURFPlugin::string_array& options)
1990 {
1991   ASSERT(myBaseImpl);
1992   for (CORBA::ULong i = 0; i < options.length(); ++i) {
1993     string name_value_type = options[i].in();
1994     if(name_value_type.empty())
1995       continue;
1996     size_t colonPos = name_value_type.find(':');
1997     string name, value;
1998     if (colonPos == string::npos) // ':' not found
1999       name = name_value_type;
2000     else {
2001       name = name_value_type.substr(0, colonPos);
2002       if (colonPos < name_value_type.size() - 1 && name_value_type[colonPos] != ' ') {
2003         string value_type = name_value_type.substr(colonPos + 1);
2004         colonPos = value_type.find(':');
2005         value = value_type.substr(0, colonPos);
2006         if (colonPos < value_type.size() - 1 && value_type[colonPos] != ' ')
2007           if ( value_type.substr(colonPos + 1) == "0" ) // is default
2008             value.clear();
2009       }
2010     }
2011     SetOptionValue(name.c_str(), value.c_str());
2012   }
2013 }
2014
2015 //=============================================================================
2016
2017 void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValues(const BLSURFPlugin::string_array& options)
2018 {
2019   ASSERT(myBaseImpl);
2020   for ( CORBA::ULong i = 0; i < options.length(); ++i) {
2021     string name_value_type = options[i].in();
2022     if(name_value_type.empty())
2023       continue;
2024     size_t colonPos = name_value_type.find(':');
2025     string name, value;
2026     if (colonPos == string::npos) // ':' not found
2027       name = name_value_type;
2028     else {
2029       name = name_value_type.substr(0, colonPos);
2030       if (colonPos < name_value_type.size() - 1 && name_value_type[colonPos] != ' ') {
2031         string value_type = name_value_type.substr(colonPos + 1);
2032         colonPos = value_type.find(':');
2033         value = value_type.substr(0, colonPos);
2034         if (colonPos < value_type.size() - 1 && value_type[colonPos] != ' ')
2035           if ( value_type.substr(colonPos + 1) == "0" ) // is default
2036             value.clear();
2037       }
2038     }
2039     SetPreCADOptionValue(name.c_str(), value.c_str());
2040   }
2041 }
2042
2043 //=============================================================================
2044
2045 void BLSURFPlugin_Hypothesis_i::SetAdvancedOptionValues(const BLSURFPlugin::string_array& options)
2046 {
2047   SMESH::TPythonDump dump;
2048
2049   string optionsAndValues;
2050   for ( CORBA::ULong i = 0; i < options.length(); ++i) {
2051     string name_value_type = options[i].in();
2052     if(name_value_type.empty())
2053       continue;
2054     size_t colonPos = name_value_type.find(':');
2055     string name, value;
2056     if (colonPos == string::npos) // ':' not found
2057       name = name_value_type;
2058     else {
2059       name = name_value_type.substr(0, colonPos);
2060       if (colonPos < name_value_type.size() - 1 && name_value_type[colonPos] != ' ') {
2061         string value_type = name_value_type.substr(colonPos + 1);
2062         colonPos = value_type.find(':');
2063         value = value_type.substr(0, colonPos);
2064       }
2065     }
2066     AddOption(name.c_str(), value.c_str());
2067
2068     optionsAndValues += name + " " + value + " ";
2069   }
2070
2071   if ( !optionsAndValues.empty() )
2072     dump << _this() << ".SetAdvancedOptions( '" << optionsAndValues.c_str() << "' )";
2073 }
2074
2075 //=============================================================================
2076
2077 void BLSURFPlugin_Hypothesis_i::SetAdvancedOption(const char* optionsAndValues)
2078 {
2079   if ( !optionsAndValues ) return;
2080
2081   SMESH::TPythonDump dump;
2082
2083   std::istringstream strm( optionsAndValues );
2084   std::istream_iterator<std::string> sIt( strm ), sEnd;
2085   while ( sIt != sEnd )
2086   {
2087     std::string option = *sIt;
2088     if ( ++sIt != sEnd )
2089     {
2090       std::string value = *sIt;
2091       ++sIt;
2092       AddOption( option.c_str(), value.c_str() );
2093     }
2094     else
2095     {
2096       THROW_SALOME_CORBA_EXCEPTION( "Uneven number of options and values" ,SALOME::BAD_PARAM );
2097     }
2098   }
2099   dump << _this() << ".SetAdvancedOption( '" << optionsAndValues << "' )";
2100 }
2101
2102 //=============================================================================
2103
2104 void BLSURFPlugin_Hypothesis_i::AddOption(const char* optionName, const char* optionValue)
2105 {
2106   // backward compatibility
2107   {
2108     std::string name( optionName );
2109     if ( name == "proximity" )
2110       SetVolumeProximity( GetImpl()->ToBool( optionValue ));
2111
2112     else if ( name == "prox_ratio" )
2113       SetVolumeProximityRatio( GetImpl()->ToDbl( optionValue ));
2114
2115     else if ( name == "prox_nb_layer" )
2116       SetNbVolumeProximityLayers( (CORBA::Short) GetImpl()->ToInt( optionValue ));
2117   }
2118   bool valueChanged = (this->GetImpl()->GetOption(optionName) != optionValue);
2119   if (valueChanged) {
2120     this->GetImpl()->AddOption(optionName, optionValue);
2121     SMESH::TPythonDump() << _this() << ".AddOption( '" << optionName << "', '" << optionValue << "' )";
2122   }
2123 }
2124
2125 //=============================================================================
2126
2127 void BLSURFPlugin_Hypothesis_i::AddPreCADOption(const char* optionName, const char* optionValue)
2128 {
2129   ASSERT(myBaseImpl);
2130   bool valueChanged = (this->GetImpl()->GetPreCADOption(optionName) != optionValue);
2131   if (valueChanged) {
2132     this->GetImpl()->AddPreCADOption(optionName, optionValue);
2133     SMESH::TPythonDump() << _this() << ".AddPreCADOption( '" << optionName << "', '" << optionValue << "' )";
2134   }
2135 }
2136
2137 //=============================================================================
2138
2139 char* BLSURFPlugin_Hypothesis_i::GetOption(const char* optionName)
2140 {
2141   ASSERT(myBaseImpl);
2142   return CORBA::string_dup(this->GetImpl()->GetOption(optionName).c_str());
2143 }
2144
2145 //=============================================================================
2146
2147 char* BLSURFPlugin_Hypothesis_i::GetPreCADOption(const char* optionName)
2148 {
2149   ASSERT(myBaseImpl);
2150   return CORBA::string_dup(this->GetImpl()->GetPreCADOption(optionName).c_str());
2151 }
2152
2153 //=============================================================================
2154
2155 void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* sizeMap)
2156 {
2157   ASSERT(myBaseImpl);
2158   if ( !entry || !entry[0] )
2159     THROW_SALOME_CORBA_EXCEPTION( "SetSizeMapEntry(): empty geom entry", SALOME::BAD_PARAM );
2160   bool valueChanged = false;
2161   try {
2162     valueChanged = (this->GetImpl()->GetSizeMapEntry(entry) != sizeMap);
2163     if (valueChanged)
2164       this->GetImpl()->SetSizeMapEntry(entry, sizeMap);
2165   } catch (const std::invalid_argument& ex) {
2166     SALOME::ExceptionStruct ExDescription;
2167     ExDescription.text = ex.what();
2168     ExDescription.type = SALOME::BAD_PARAM;
2169     ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetSizeMapEntry(entry,sizemap)";
2170     ExDescription.lineNumber = 0;
2171     throw SALOME::SALOME_Exception(ExDescription);
2172   } catch (SALOME_Exception& ex) {
2173     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
2174   }
2175   if (valueChanged)
2176     SMESH::TPythonDump() << _this() << ".SetSizeMap(" << entry << ", '" << sizeMap << "' )";
2177 }
2178
2179 //=============================================================================
2180
2181 void BLSURFPlugin_Hypothesis_i::SetConstantSizeMapEntry(const char* entry, GEOM::shape_type shapeType, CORBA::Double sizeMap)
2182 {
2183   ASSERT(myBaseImpl);
2184   bool valueChanged = false;
2185   std::ostringstream sizeMapFunction;
2186   switch (shapeType) {
2187   case GEOM::FACE:   sizeMapFunction << "def f(u,v): return " << sizeMap ; break;
2188   case GEOM::EDGE:   sizeMapFunction << "def f(t): return " << sizeMap ; break;
2189   case GEOM::VERTEX: sizeMapFunction << "def f(): return " << sizeMap ; break;
2190   default:;
2191   }
2192   try {
2193     valueChanged = (this->GetImpl()->GetSizeMapEntry(entry) != sizeMapFunction.str());
2194     if (valueChanged)
2195       this->GetImpl()->SetSizeMapEntry(entry, sizeMapFunction.str());
2196   } catch (const std::invalid_argument& ex) {
2197     SALOME::ExceptionStruct ExDescription;
2198     ExDescription.text = ex.what();
2199     ExDescription.type = SALOME::BAD_PARAM;
2200     ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetSizeMapEntry(entry,sizemap)";
2201     ExDescription.lineNumber = 0;
2202     throw SALOME::SALOME_Exception(ExDescription);
2203   } catch (SALOME_Exception& ex) {
2204     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
2205   }
2206   if (valueChanged)
2207     SMESH::TPythonDump() << _this() << ".SetConstantSizeMap(" << entry << ", " << sizeMap << " )";
2208 }
2209
2210 //=============================================================================
2211
2212 void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry, const char* attractor)
2213 {
2214   ASSERT(myBaseImpl);
2215   bool valueChanged = false;
2216   try {
2217     valueChanged = ( this->GetImpl()->GetAttractorEntry(entry) != attractor );
2218     if ( valueChanged ) {
2219       boost::regex re("^ATTRACTOR\\((?:(-?0(\\.\\d*)*|-?[1-9]+\\d*(\\.\\d*)*|-?\\.(\\d)+);){5}(True|False)(?:;(-?0(\\.\\d*)*|-?[1-9]+\\d*(\\.\\d*)*|-?\\.(\\d)+))?\\)$");
2220       if (!boost::regex_match(string(attractor), re))
2221         throw std::invalid_argument("Error: an attractor is defined with the following pattern: ATTRACTOR(xa;ya;za;a;b;True|False;d(opt.))");
2222       this->GetImpl()->SetAttractorEntry(entry, attractor);
2223     }
2224   } catch (const std::invalid_argument& ex) {
2225     SALOME::ExceptionStruct ExDescription;
2226     ExDescription.text = ex.what();
2227     ExDescription.type = SALOME::BAD_PARAM;
2228     ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetAttractorEntry(entry,attractor)";
2229     ExDescription.lineNumber = 0;
2230     throw SALOME::SALOME_Exception(ExDescription);
2231   } catch (SALOME_Exception& ex) {
2232     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
2233   }
2234   if (valueChanged)
2235     SMESH::TPythonDump() << _this() << ".SetAttractor(" << entry << ", '" << attractor << "' )";
2236 }
2237
2238 //=============================================================================
2239
2240 void BLSURFPlugin_Hypothesis_i::SetClassAttractorEntry(const char* entry, const char* att_entry, CORBA::Double StartSize, CORBA::Double EndSize, CORBA::Double ActionRadius, CORBA::Double ConstantRadius) //TODO ?? finir
2241 {
2242   ASSERT(myBaseImpl);
2243   //bool valueChanged = false;
2244   try {
2245     this->GetImpl()->SetClassAttractorEntry(entry, att_entry, StartSize, EndSize, ActionRadius, ConstantRadius);
2246   }
2247   catch (const std::invalid_argument& ex) {
2248     SALOME::ExceptionStruct ExDescription;
2249     ExDescription.text = ex.what();
2250     ExDescription.type = SALOME::BAD_PARAM;
2251     ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetClassAttractorEntry(entry, att_entry, StartSize, EndSize, ActionRadius, ConstantRadius)";
2252     ExDescription.lineNumber = 0;
2253     throw SALOME::SALOME_Exception(ExDescription);
2254   } catch (SALOME_Exception& ex) {
2255     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
2256   }
2257   //if ( valueChanged )
2258   SMESH::TPythonDump() << _this() << ".SetAttractorGeom( "
2259                        << entry << ", " << att_entry << ", "<<StartSize<<", "<<EndSize<<", "<<ActionRadius<<", "<<ConstantRadius<<" )";
2260 }
2261
2262 //=============================================================================
2263
2264 char* BLSURFPlugin_Hypothesis_i::GetSizeMapEntry(const char* entry) {
2265   ASSERT(myBaseImpl);
2266   try {
2267     return CORBA::string_dup(this->GetImpl()->GetSizeMapEntry(entry).c_str());
2268   } catch (const std::invalid_argument& ex) {
2269     SALOME::ExceptionStruct ExDescription;
2270     ExDescription.text = ex.what();
2271     ExDescription.type = SALOME::BAD_PARAM;
2272     ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::GetSizeMapEntry(name)";
2273     ExDescription.lineNumber = 0;
2274     throw SALOME::SALOME_Exception(ExDescription);
2275   } catch (SALOME_Exception& ex) {
2276     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
2277   }
2278   return 0;
2279 }
2280
2281 //=============================================================================
2282
2283 char* BLSURFPlugin_Hypothesis_i::GetAttractorEntry(const char* entry) {
2284   ASSERT(myBaseImpl);
2285   try {
2286     return CORBA::string_dup(this->GetImpl()->GetAttractorEntry(entry).c_str());
2287   } catch (const std::invalid_argument& ex) {
2288     SALOME::ExceptionStruct ExDescription;
2289     ExDescription.text = ex.what();
2290     ExDescription.type = SALOME::BAD_PARAM;
2291     ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::GetAttractorEntry(name)";
2292     ExDescription.lineNumber = 0;
2293     throw SALOME::SALOME_Exception(ExDescription);
2294   } catch (SALOME_Exception& ex) {
2295     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
2296   }
2297   return 0;
2298 }
2299
2300 // //=============================================================================
2301 // 
2302 // // TODO coder cette fonction (utilis??e pour savoir si la valeur a chang??
2303 // // A finir pour le dump
2304 // char* BLSURFPlugin_Hypothesis_i::GetClassAttractorEntry(const char* entry)
2305 // {
2306 //   ASSERT(myBaseImpl);
2307 //   try {
2308 //     return CORBA::string_dup( this->GetImpl()->GetClassAttractorEntry(entry).c_str());
2309 //   }
2310 //   catch (const std::invalid_argument& ex) {
2311 //     SALOME::ExceptionStruct ExDescription;
2312 //     ExDescription.text = ex.what();
2313 //     ExDescription.type = SALOME::BAD_PARAM;
2314 //     ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::GetClassAttractorEntry(name)";
2315 //     ExDescription.lineNumber = 0;
2316 //     throw SALOME::SALOME_Exception(ExDescription);
2317 //   }
2318 //   catch (SALOME_Exception& ex) {
2319 //     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
2320 //   }
2321 //   return 0;
2322 // }
2323
2324 //=============================================================================
2325
2326 void BLSURFPlugin_Hypothesis_i::UnsetEntry(const char* entry) {
2327   ASSERT(myBaseImpl);
2328   this->GetImpl()->ClearEntry(entry);
2329   //  SMESH::TPythonDump() << _this() << ".UnsetSizeMap( " << entry << " )";
2330 }
2331
2332 //=============================================================================
2333
2334 BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetSizeMapEntries() {
2335   ASSERT(myBaseImpl);
2336   BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array();
2337
2338   const ::BLSURFPlugin_Hypothesis::TSizeMap sizeMaps = this->GetImpl()->_GetSizeMapEntries();
2339   result->length((CORBA::ULong) sizeMaps.size());
2340
2341   ::BLSURFPlugin_Hypothesis::TSizeMap::const_iterator smIt = sizeMaps.begin();
2342   for (int i = 0; smIt != sizeMaps.end(); ++smIt, ++i) {
2343     string entry_sizemap = smIt->first;
2344     if (!smIt->second.empty()) {
2345       entry_sizemap += "|";
2346       entry_sizemap += smIt->second;
2347     }
2348     result[i] = CORBA::string_dup(entry_sizemap.c_str());
2349   }
2350   return result._retn();
2351 }
2352
2353 //=============================================================================
2354
2355 BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetAttractorEntries() {
2356   ASSERT(myBaseImpl);
2357   BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array();
2358
2359   const ::BLSURFPlugin_Hypothesis::TSizeMap attractors = this->GetImpl()->_GetAttractorEntries();
2360   result->length((CORBA::ULong) attractors.size());
2361
2362   ::BLSURFPlugin_Hypothesis::TSizeMap::const_iterator atIt = attractors.begin();
2363   for (int i = 0; atIt != attractors.end(); ++atIt, ++i) {
2364     string entry_attractor = atIt->first;
2365     if (!atIt->second.empty()) {
2366       entry_attractor += "|";
2367       entry_attractor += atIt->second;
2368     }
2369     result[i] = CORBA::string_dup(entry_attractor.c_str());
2370   }
2371   return result._retn();
2372 }
2373
2374 //=============================================================================
2375
2376 BLSURFPlugin::TAttParamsMap* BLSURFPlugin_Hypothesis_i::GetAttractorParams()
2377 {
2378   ASSERT(myBaseImpl);
2379   BLSURFPlugin::TAttParamsMap_var result = new BLSURFPlugin::TAttParamsMap();
2380
2381   const ::BLSURFPlugin_Hypothesis::TAttractorMap attractors= this->GetImpl()->_GetClassAttractorEntries();
2382   result->length((CORBA::ULong) attractors.size() );
2383
2384   ::BLSURFPlugin_Hypothesis::TAttractorMap::const_iterator atIt = attractors.begin();
2385   for ( int i = 0 ; atIt != attractors.end(); ++atIt, ++i ) {
2386     string faceEntry = atIt->first;
2387     string attEntry;
2388     double startSize=0., endSize=0., infDist=0., constDist=0.;
2389     if ( !atIt->second->Empty() ) {
2390       attEntry = atIt->second->GetAttractorEntry();
2391       std::vector<double> params = atIt->second->GetParameters();
2392       startSize = params[0];
2393       endSize = params[1];
2394       infDist = params[2];
2395       constDist = params[3];
2396     }
2397     result[i].faceEntry = CORBA::string_dup(faceEntry.c_str());
2398     result[i].attEntry = CORBA::string_dup(attEntry.c_str());
2399     result[i].startSize = startSize;
2400     result[i].endSize = endSize;
2401     result[i].infDist = infDist;
2402     result[i].constDist = constDist;
2403   }
2404   return result._retn();
2405 }
2406
2407 //=============================================================================
2408
2409 void BLSURFPlugin_Hypothesis_i::SetSizeMapEntries(const BLSURFPlugin::string_array& sizeMaps)
2410 {
2411   ASSERT(myBaseImpl);
2412   for ( CORBA::ULong i = 0; i < sizeMaps.length(); ++i) {
2413     string entry_sizemap = sizeMaps[i].in();
2414     size_t colonPos = entry_sizemap.find('|');
2415     string entry, sizemap;
2416     if (colonPos == string::npos) // '|' separator not found
2417       entry = entry_sizemap;
2418     else {
2419       entry = entry_sizemap.substr(0, colonPos);
2420       if (colonPos < entry_sizemap.size() - 1 && entry_sizemap[colonPos] != ' ')
2421         sizemap = entry_sizemap.substr(colonPos + 1);
2422     }
2423     this->GetImpl()->SetSizeMapEntry(entry.c_str(), sizemap.c_str());
2424   }
2425 }
2426
2427 //=============================================================================
2428
2429 void BLSURFPlugin_Hypothesis_i::ClearSizeMaps() {
2430   ASSERT(myBaseImpl);
2431   this->GetImpl()->ClearSizeMaps();
2432 }
2433
2434 //=============================================================================
2435
2436 void BLSURFPlugin_Hypothesis_i::SetSizeMap(const GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap)
2437 {
2438   ASSERT(myBaseImpl);
2439   string entry;
2440   entry = GeomObj->GetStudyEntry();
2441   SetSizeMapEntry(entry.c_str(), sizeMap);
2442 }
2443
2444 //=============================================================================
2445
2446 void BLSURFPlugin_Hypothesis_i::SetConstantSizeMap(const GEOM::GEOM_Object_ptr GeomObj, CORBA::Double sizeMap) {
2447   ASSERT(myBaseImpl);
2448   string entry = GeomObj->GetStudyEntry();
2449   GEOM::shape_type shapeType = GeomObj->GetShapeType();
2450   if (shapeType == GEOM::COMPOUND)
2451     shapeType = GeomObj->GetMaxShapeType();
2452   SetConstantSizeMapEntry(entry.c_str(), shapeType, sizeMap);
2453 }
2454
2455 //=============================================================================
2456 void BLSURFPlugin_Hypothesis_i::UnsetSizeMap(const GEOM::GEOM_Object_ptr GeomObj) {
2457   ASSERT(myBaseImpl);
2458   string entry;
2459   entry = GeomObj->GetStudyEntry();
2460   UnsetEntry(entry.c_str());
2461   SMESH::TPythonDump() << _this() << ".UnsetSizeMap( " << entry.c_str() << " )";
2462 }
2463
2464 void BLSURFPlugin_Hypothesis_i::SetAttractor(GEOM::GEOM_Object_ptr GeomObj, const char* attractor) {
2465   ASSERT(myBaseImpl);
2466   string entry;
2467   entry = GeomObj->GetStudyEntry();
2468   SetAttractorEntry(entry.c_str(), attractor);
2469 }
2470
2471 void BLSURFPlugin_Hypothesis_i::UnsetAttractor(GEOM::GEOM_Object_ptr GeomObj) {
2472   ASSERT(myBaseImpl);
2473   string entry;
2474   entry = GeomObj->GetStudyEntry();
2475   UnsetEntry(entry.c_str());
2476   SMESH::TPythonDump() << _this() << ".UnsetAttractor( " << entry.c_str() << " )";
2477 }
2478
2479 void BLSURFPlugin_Hypothesis_i::SetAttractorGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theAttractor, CORBA::Double StartSize, CORBA::Double EndSize, CORBA::Double ActionRadius, CORBA::Double ConstantRadius)
2480 {
2481   ASSERT(myBaseImpl);
2482   string theFaceEntry;
2483   string theAttEntry;
2484   theFaceEntry = theFace->GetStudyEntry();
2485   theAttEntry  = theAttractor->GetStudyEntry();
2486   
2487   GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
2488   string aName;
2489   
2490   if (theFaceEntry.empty()) {
2491     aName = "Face_";
2492     aName += theFace->GetEntry();
2493     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
2494     if (!theSFace->_is_nil())
2495       theFaceEntry = theSFace->GetID();
2496   }
2497   if (theFaceEntry.empty())
2498     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
2499   
2500   if (theAttEntry.empty()) {
2501     if (theAttractor->GetShapeType() == GEOM::VERTEX)
2502       aName = "Vertex_";
2503     if (theAttractor->GetShapeType() == GEOM::EDGE)
2504       aName = "Edge_";
2505     if (theAttractor->GetShapeType() == GEOM::WIRE)
2506       aName = "Wire_";
2507     if (theAttractor->GetShapeType() == GEOM::COMPOUND)
2508       aName = "Compound_";
2509     aName += theAttractor->GetEntry();
2510     SALOMEDS::SObject_wrap theSAtt = geomGen->PublishInStudy(NULL, theAttractor, aName.c_str());
2511     if (!theSAtt->_is_nil())
2512       theAttEntry = theSAtt->GetID();
2513   }
2514   if (theAttEntry.empty())
2515     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
2516   
2517   TopoDS_Face FaceShape = TopoDS::Face(SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theFace ));
2518   TopoDS_Shape AttractorShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theAttractor );
2519   SetClassAttractorEntry( theFaceEntry.c_str(), theAttEntry.c_str(), StartSize, EndSize, ActionRadius, ConstantRadius);
2520 }
2521
2522 void BLSURFPlugin_Hypothesis_i::UnsetAttractorGeom(GEOM::GEOM_Object_ptr theFace,
2523                                                    GEOM::GEOM_Object_ptr theAttractor)
2524 {
2525   ASSERT(myBaseImpl);
2526   CORBA::String_var theFaceEntry = theFace->GetStudyEntry();
2527   CORBA::String_var theAttrEntry = theAttractor->GetStudyEntry();
2528   
2529   // GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
2530   // string aName;
2531   
2532   // if (theFaceEntry.empty()) {
2533   //   aName = "Face_";
2534   //   aName += theFace->GetEntry();
2535   //   SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
2536   //   if (!theSFace->_is_nil())
2537   //     theFaceEntry = theSFace->GetID();
2538   // }
2539   if ( !theFaceEntry.in() || !theFaceEntry.in()[0] ||
2540        !theAttrEntry.in() || !theAttrEntry.in()[0] )
2541     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
2542   
2543   GetImpl()->ClearEntry( theFaceEntry.in(), theAttrEntry.in() );
2544   SMESH::TPythonDump() << _this() << ".UnsetAttractorGeom( "
2545                        << theFace << ", " << theAttractor << " )";
2546 }
2547
2548 void BLSURFPlugin_Hypothesis_i::UnsetAttractorEntry(const char* faceEntry,
2549                                                     const char* attractorEntry)
2550 {
2551   GetImpl()->ClearEntry( faceEntry, attractorEntry );
2552   SMESH::TPythonDump() << _this() << ".UnsetAttractorEntry( '"
2553                        << faceEntry << "', '" << attractorEntry << "' )";
2554 }
2555
2556
2557 /*
2558   void BLSURFPlugin_Hypothesis_i::SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap)
2559   {}
2560
2561   void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj)
2562   {}
2563
2564   void BLSURFPlugin_Hypothesis_i::SetCustomSizeMapEntry(const char* entry,const char* sizeMap )
2565   {}
2566
2567   char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry)
2568   {}
2569
2570   void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry)
2571   {
2572   ASSERT(myBaseImpl);
2573   this->GetImpl()->UnsetCustomSizeMap(entry);
2574   SMESH::TPythonDump() << _this() << ".UnsetCustomSizeMap( " << entry << " )";
2575   }
2576
2577
2578   BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntries()
2579   {}
2580
2581 */
2582
2583 // ///////////////////////
2584 // // ENFORCED VERTICES //
2585 // ///////////////////////
2586
2587
2588 /**
2589  * Returns the list of enforced vertices for a given Face entry
2590  * @return A map of Face entry / List of enforced vertices
2591  *
2592  */
2593 BLSURFPlugin::TFaceEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByFace() {
2594   ASSERT(myBaseImpl);
2595
2596   BLSURFPlugin::TFaceEntryEnfVertexListMap_var resultMap = new BLSURFPlugin::TFaceEntryEnfVertexListMap();
2597
2598   const ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap faceEntryEnfVertexListMap =
2599     this->GetImpl()->_GetAllEnforcedVerticesByFace();
2600   resultMap->length((CORBA::ULong) faceEntryEnfVertexListMap.size());
2601
2602   ::BLSURFPlugin_Hypothesis::TEnfVertexList _enfVertexList;
2603   ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap::const_iterator it_entry = faceEntryEnfVertexListMap.begin();
2604   for (int i = 0; it_entry != faceEntryEnfVertexListMap.end(); ++it_entry, ++i) {
2605     BLSURFPlugin::TFaceEntryEnfVertexListMapElement_var mapElement =
2606       new BLSURFPlugin::TFaceEntryEnfVertexListMapElement();
2607     mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str());
2608
2609     _enfVertexList = it_entry->second;
2610     BLSURFPlugin::TEnfVertexList_var enfVertexList = new BLSURFPlugin::TEnfVertexList();
2611     enfVertexList->length((CORBA::ULong) _enfVertexList.size());
2612
2613     ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator it_enfVertex = _enfVertexList.begin();
2614     ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
2615     for (int j = 0; it_enfVertex != _enfVertexList.end(); ++it_enfVertex, ++j) {
2616       currentEnfVertex = (*it_enfVertex);
2617
2618       BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
2619
2620       // Name
2621       enfVertex->name = CORBA::string_dup(currentEnfVertex->name.c_str());
2622
2623       // Geom entry
2624       enfVertex->geomEntry = CORBA::string_dup(currentEnfVertex->geomEntry.c_str());
2625
2626       // Coords
2627       BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
2628       coords->length((CORBA::ULong) currentEnfVertex->coords.size());
2629       for (CORBA::ULong i=0;i<coords->length();i++)
2630         coords[i] = currentEnfVertex->coords[i];
2631       enfVertex->coords = coords;
2632
2633       // Group name
2634       enfVertex->grpName = CORBA::string_dup(currentEnfVertex->grpName.c_str());
2635       
2636       // Face entry list
2637       BLSURFPlugin::TEntryList_var faceEntryList = new BLSURFPlugin::TEntryList();
2638       faceEntryList->length((CORBA::ULong) currentEnfVertex->faceEntries.size());
2639       ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_entry = currentEnfVertex->faceEntries.begin();
2640       for (int ind = 0; it_entry != currentEnfVertex->faceEntries.end();++it_entry, ++ind)
2641         faceEntryList[ind] = CORBA::string_dup((*it_entry).c_str());
2642       enfVertex->faceEntries = faceEntryList;
2643
2644       ostringstream msg;
2645       msg << "Enforced vertex: \n"
2646           << "Name: " << enfVertex->name << "\n";
2647       if (coords->length())
2648         msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
2649       msg << "Geom entry: " << enfVertex->geomEntry << "\n"
2650           << "Group Name: " << enfVertex->grpName;
2651
2652       enfVertexList[j] = enfVertex;
2653     }
2654     mapElement->enfVertexList = enfVertexList;
2655
2656     resultMap[i] = mapElement;
2657
2658   }
2659   return resultMap._retn();
2660 }
2661
2662 /**
2663  * Returns the list of all enforced vertices
2664  * @return a list of enforced vertices
2665  *
2666  */
2667 BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices() {
2668   ASSERT(myBaseImpl);
2669   BLSURFPlugin::TEnfVertexList_var resultMap = new BLSURFPlugin::TEnfVertexList();
2670   const ::BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList = this->GetImpl()->_GetAllEnforcedVertices();
2671   resultMap->length((CORBA::ULong) enfVertexList.size());
2672
2673   ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = enfVertexList.begin();
2674   ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
2675   for (int i = 0; evlIt != enfVertexList.end(); ++evlIt, ++i) {
2676     currentEnfVertex = (*evlIt);
2677     BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
2678     // Name
2679     enfVertex->name = CORBA::string_dup(currentEnfVertex->name.c_str());
2680     // Geom entry
2681     enfVertex->geomEntry = CORBA::string_dup(currentEnfVertex->geomEntry.c_str());
2682     // Coords
2683     BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
2684     coords->length((CORBA::ULong) currentEnfVertex->coords.size());
2685     for (CORBA::ULong ind = 0; ind < coords->length(); ind++)
2686       coords[ind] = currentEnfVertex->coords[ind];
2687     enfVertex->coords = coords;
2688     // Group name
2689     enfVertex->grpName = CORBA::string_dup(currentEnfVertex->grpName.c_str());  
2690     // Face entry list
2691     BLSURFPlugin::TEntryList_var faceEntryList = new BLSURFPlugin::TEntryList();
2692     faceEntryList->length((CORBA::ULong) currentEnfVertex->faceEntries.size());
2693     ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_entry = currentEnfVertex->faceEntries.begin();
2694     for (int ind = 0; it_entry != currentEnfVertex->faceEntries.end();++it_entry, ++ind)
2695       faceEntryList[ind] = CORBA::string_dup((*it_entry).c_str());
2696     enfVertex->faceEntries = faceEntryList;
2697
2698     ostringstream msg;
2699     msg << "Enforced vertex: \n"
2700         << "Name: " << enfVertex->name << "\n";
2701     if (coords->length())
2702       msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
2703     msg << "Geom entry: " << enfVertex->geomEntry << "\n"
2704         << "Group Name: " << enfVertex->grpName;
2705
2706     resultMap[i] = enfVertex;
2707   }
2708   return resultMap._retn();
2709
2710 }
2711
2712 /**
2713  * Returns the list of enforced vertices coords for a given Face entry.
2714  * They are the coords of the "manual" enforced vertices.
2715  * @return A map of Face entry / List of enforced vertices coords
2716  *
2717  */
2718 BLSURFPlugin::TFaceEntryCoordsListMap* BLSURFPlugin_Hypothesis_i::GetAllCoordsByFace() {
2719   ASSERT(myBaseImpl);
2720
2721   BLSURFPlugin::TFaceEntryCoordsListMap_var resultMap = new BLSURFPlugin::TFaceEntryCoordsListMap();
2722
2723   const ::BLSURFPlugin_Hypothesis::TFaceEntryCoordsListMap entryCoordsListMap = this->GetImpl()->_GetAllCoordsByFace();
2724   resultMap->length((CORBA::ULong) entryCoordsListMap.size());
2725
2726   ::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList _coordsList;
2727   ::BLSURFPlugin_Hypothesis::TFaceEntryCoordsListMap::const_iterator it_entry = entryCoordsListMap.begin();
2728   for (int i = 0; it_entry != entryCoordsListMap.end(); ++it_entry, ++i) {
2729     BLSURFPlugin::TFaceEntryCoordsListMapElement_var mapElement = new BLSURFPlugin::TFaceEntryCoordsListMapElement();
2730     mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str());
2731
2732     _coordsList = it_entry->second;
2733     BLSURFPlugin::TEnfVertexCoordsList_var coordsList = new BLSURFPlugin::TEnfVertexCoordsList();
2734     coordsList->length((CORBA::ULong) _coordsList.size());
2735
2736     ::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList::const_iterator it_coords = _coordsList.begin();
2737     for (int j = 0; it_coords != _coordsList.end(); ++it_coords, ++j) {
2738       BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
2739       coords->length((CORBA::ULong) (*it_coords).size());
2740       for (CORBA::ULong i=0;i<coords->length();i++)
2741         coords[i] = (*it_coords)[i];
2742       coordsList[j] = coords;
2743     }
2744     mapElement->coordsList = coordsList;
2745
2746     resultMap[i] = mapElement;
2747
2748   }
2749   return resultMap._retn();
2750 }
2751
2752 /**
2753  * Returns a map of enforced vertices coords / enforced vertex.
2754  * They are the coords of the "manual" enforced vertices.
2755  */
2756 BLSURFPlugin::TCoordsEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByCoords() {
2757   ASSERT(myBaseImpl);
2758
2759   BLSURFPlugin::TCoordsEnfVertexMap_var resultMap = new BLSURFPlugin::TCoordsEnfVertexMap();
2760   const ::BLSURFPlugin_Hypothesis::TCoordsEnfVertexMap coordsEnfVertexMap =
2761     this->GetImpl()->_GetAllEnforcedVerticesByCoords();
2762   resultMap->length((CORBA::ULong) coordsEnfVertexMap.size());
2763
2764   ::BLSURFPlugin_Hypothesis::TCoordsEnfVertexMap::const_iterator it_coords = coordsEnfVertexMap.begin();
2765   ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
2766   for (int i = 0; it_coords != coordsEnfVertexMap.end(); ++it_coords, ++i) {
2767     currentEnfVertex = (it_coords->second);
2768     BLSURFPlugin::TCoordsEnfVertexElement_var mapElement = new BLSURFPlugin::TCoordsEnfVertexElement();
2769     BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
2770     coords->length((CORBA::ULong) it_coords->first.size());
2771     for (CORBA::ULong ind=0;ind<coords->length();ind++)
2772       coords[ind] = it_coords->first[ind];
2773     mapElement->coords = coords;
2774
2775     BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
2776     // Name
2777     enfVertex->name = CORBA::string_dup(currentEnfVertex->name.c_str());
2778     // Geom entry
2779     enfVertex->geomEntry = CORBA::string_dup(currentEnfVertex->geomEntry.c_str());
2780     // Coords
2781     BLSURFPlugin::TEnfVertexCoords_var coords2 = new BLSURFPlugin::TEnfVertexCoords();
2782     coords2->length((CORBA::ULong) currentEnfVertex->coords.size());
2783     for (CORBA::ULong ind=0;ind<coords2->length();ind++)
2784       coords2[ind] = currentEnfVertex->coords[ind];
2785     enfVertex->coords = coords2;
2786     // Group name
2787     enfVertex->grpName = CORBA::string_dup(currentEnfVertex->grpName.c_str());  
2788     // Face entry list
2789     BLSURFPlugin::TEntryList_var faceEntryList = new BLSURFPlugin::TEntryList();
2790     faceEntryList->length((CORBA::ULong) currentEnfVertex->faceEntries.size());
2791     ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_entry = currentEnfVertex->faceEntries.begin();
2792     for (int ind = 0; it_entry != currentEnfVertex->faceEntries.end();++it_entry, ++ind)
2793       faceEntryList[ind] = CORBA::string_dup((*it_entry).c_str());
2794     enfVertex->faceEntries = faceEntryList;
2795       
2796     mapElement->enfVertex = enfVertex;
2797     ostringstream msg;
2798     msg << "Enforced vertex: \n"
2799         << "Name: " << enfVertex->name << "\n";
2800     if (coords->length())
2801       msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
2802     msg << "Geom entry: " << enfVertex->geomEntry << "\n"
2803         << "Group Name: " << enfVertex->grpName;
2804
2805     resultMap[i] = mapElement;
2806   }
2807   return resultMap._retn();
2808 }
2809
2810 /**
2811  * Returns the list of enforced vertices entries for a given Face entry.
2812  * They are the geom entries of the enforced vertices based on geom shape (vertex, compound, group).
2813  * @return A map of Face entry / List of enforced vertices geom entries
2814  *
2815  */
2816 BLSURFPlugin::TFaceEntryEnfVertexEntryListMap* BLSURFPlugin_Hypothesis_i::GetAllEnfVertexEntriesByFace() {
2817   ASSERT(myBaseImpl);
2818
2819   BLSURFPlugin::TFaceEntryEnfVertexEntryListMap_var resultMap = new BLSURFPlugin::TFaceEntryEnfVertexEntryListMap();
2820
2821   const ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexEntryListMap entryEnfVertexEntryListMap =
2822     this->GetImpl()->_GetAllEnfVertexEntriesByFace();
2823   resultMap->length((CORBA::ULong) entryEnfVertexEntryListMap.size());
2824
2825   ::BLSURFPlugin_Hypothesis::TEntryList _enfVertexEntryList;
2826   ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexEntryListMap::const_iterator it_entry =
2827       entryEnfVertexEntryListMap.begin();
2828   for (int i = 0; it_entry != entryEnfVertexEntryListMap.end(); ++it_entry, ++i) {
2829     BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement_var mapElement =
2830       new BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement();
2831     mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str());
2832
2833     _enfVertexEntryList = it_entry->second;
2834     BLSURFPlugin::TEntryList_var enfVertexEntryList = new BLSURFPlugin::TEntryList();
2835     enfVertexEntryList->length((CORBA::ULong) _enfVertexEntryList.size());
2836
2837     ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_enfVertexEntry = _enfVertexEntryList.begin();
2838     for (int j = 0; it_enfVertexEntry != _enfVertexEntryList.end(); ++it_enfVertexEntry, ++j) {
2839       enfVertexEntryList[j] = CORBA::string_dup((*it_enfVertexEntry).c_str());
2840     }
2841     mapElement->enfVertexEntryList = enfVertexEntryList;
2842
2843     resultMap[i] = mapElement;
2844
2845   }
2846   return resultMap._retn();
2847 }
2848
2849 /**
2850  * Returns a map of enforced vertices geom entry / enforced vertex.
2851  * They are the geom entries of the enforced vertices defined with geom shape (vertex, compound, group).
2852  */
2853 BLSURFPlugin::TEnfVertexEntryEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByEnfVertexEntry() {
2854   ASSERT(myBaseImpl);
2855
2856   BLSURFPlugin::TEnfVertexEntryEnfVertexMap_var resultMap = new BLSURFPlugin::TEnfVertexEntryEnfVertexMap();
2857   const ::BLSURFPlugin_Hypothesis::TEnfVertexEntryEnfVertexMap enfVertexEntryEnfVertexMap =
2858     this->GetImpl()->_GetAllEnforcedVerticesByEnfVertexEntry();
2859   resultMap->length((CORBA::ULong) enfVertexEntryEnfVertexMap.size());
2860
2861   ::BLSURFPlugin_Hypothesis::TEnfVertexEntryEnfVertexMap::const_iterator it_enfVertexEntry = enfVertexEntryEnfVertexMap.begin();
2862   ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
2863   for (int i = 0; it_enfVertexEntry != enfVertexEntryEnfVertexMap.end(); ++it_enfVertexEntry, ++i) {
2864     currentEnfVertex = it_enfVertexEntry->second;
2865     BLSURFPlugin::TEnfVertexEntryEnfVertexElement_var mapElement = new BLSURFPlugin::TEnfVertexEntryEnfVertexElement();
2866     mapElement->enfVertexEntry = CORBA::string_dup(it_enfVertexEntry->first.c_str());;
2867
2868     BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
2869     // Name
2870     enfVertex->name = CORBA::string_dup(currentEnfVertex->name.c_str());
2871     // Geom entry
2872     enfVertex->geomEntry = CORBA::string_dup(currentEnfVertex->geomEntry.c_str());
2873     // Coords
2874     BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
2875     coords->length((CORBA::ULong) currentEnfVertex->coords.size());
2876     for (CORBA::ULong ind=0;ind<coords->length();ind++)
2877       coords[ind] = currentEnfVertex->coords[ind];
2878     enfVertex->coords = coords;
2879     // Group name
2880     enfVertex->grpName = CORBA::string_dup(currentEnfVertex->grpName.c_str());  
2881     // Face entry list
2882     BLSURFPlugin::TEntryList_var faceEntryList = new BLSURFPlugin::TEntryList();
2883     faceEntryList->length((CORBA::ULong) currentEnfVertex->faceEntries.size());
2884     ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_entry = currentEnfVertex->faceEntries.begin();
2885     for (int ind = 0; it_entry != currentEnfVertex->faceEntries.end();++it_entry, ++ind)
2886       faceEntryList[ind] = CORBA::string_dup((*it_entry).c_str());
2887     enfVertex->faceEntries = faceEntryList;
2888
2889     ostringstream msg;
2890     msg << "Enforced vertex: \n"
2891         << "Name: " << enfVertex->name << "\n";
2892     if (coords->length())
2893       msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
2894     msg << "Geom entry: " << enfVertex->geomEntry << "\n"
2895         << "Group Name: " << enfVertex->grpName;
2896
2897     mapElement->enfVertex = enfVertex;
2898     resultMap[i] = mapElement;
2899   }
2900   return resultMap._retn();
2901 }
2902
2903 /**
2904  * Erase all enforced vertices
2905  */
2906 void BLSURFPlugin_Hypothesis_i::ClearAllEnforcedVertices() {
2907   ASSERT(myBaseImpl);
2908   this->GetImpl()->ClearAllEnforcedVertices();
2909   SMESH::TPythonDump() << _this() << ".ClearAllEnforcedVertices()";
2910 }
2911
2912 /*!
2913  * Set/get/unset an enforced vertex on face - OBSOLETE
2914  */
2915 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
2916                                                   CORBA::Double z) {
2917   ASSERT(myBaseImpl);
2918
2919   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
2920     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
2921   }
2922
2923   string theFaceEntry = theFace->GetStudyEntry();
2924   
2925   if (theFaceEntry.empty()) {
2926     GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
2927     string aName;
2928     if (theFace->GetShapeType() == GEOM::FACE)
2929       aName = "Face_";
2930     if (theFace->GetShapeType() == GEOM::COMPOUND)
2931       aName = "Compound_";
2932     aName += theFace->GetEntry();
2933     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
2934     if (!theSFace->_is_nil())
2935       theFaceEntry = theSFace->GetID();
2936   }
2937   if (theFaceEntry.empty())
2938     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
2939   try {
2940     return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z);
2941   } catch (SALOME_Exception& ex) {
2942     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
2943   }
2944 }
2945
2946 /*!
2947  * Set/get/unset an enforced vertex with name on face
2948  */
2949 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
2950                                                        CORBA::Double z, const char* theVertexName) {
2951   ASSERT(myBaseImpl);
2952
2953   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
2954     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
2955   }
2956
2957   string theFaceEntry = theFace->GetStudyEntry();
2958   
2959   if (theFaceEntry.empty()) {
2960     GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
2961     string aName;
2962     if (theFace->GetShapeType() == GEOM::FACE)
2963       aName = "Face_";
2964     if (theFace->GetShapeType() == GEOM::COMPOUND)
2965       aName = "Compound_";
2966     aName += theFace->GetEntry();
2967     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
2968     if (!theSFace->_is_nil())
2969       theFaceEntry = theSFace->GetID();
2970   }
2971   if (theFaceEntry.empty())
2972     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
2973   
2974   try {
2975     return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, theVertexName);
2976   } catch (SALOME_Exception& ex) {
2977     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
2978   }
2979 }
2980
2981 /*!
2982  * Set/get/unset an enforced vertex with geom object on face
2983  */
2984 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
2985 {
2986   ASSERT(myBaseImpl);
2987
2988   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
2989     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
2990   }
2991
2992   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
2993     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
2994   }
2995
2996   //  GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
2997   //  GEOM::GEOM_IMeasureOperations_var measureOp = geomGen->GetIMeasureOperations();
2998   //  if (CORBA::is_nil(measureOp))
2999   //    return false;
3000   //
3001   //  CORBA::Double x, y, z;
3002   //  x = y = z = 0.;
3003   //  measureOp->PointCoordinates(theVertex, x, y, z);
3004
3005   string theFaceEntry = theFace->GetStudyEntry();
3006   string theVertexEntry = theVertex->GetStudyEntry();
3007   
3008   GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3009   string aName;
3010   
3011   if (theFaceEntry.empty()) {
3012     if (theFace->GetShapeType() == GEOM::FACE)
3013       aName = "Face_";
3014     if (theFace->GetShapeType() == GEOM::COMPOUND)
3015       aName = "Compound_";
3016     aName += theFace->GetEntry();
3017     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
3018     if (!theSFace->_is_nil())
3019       theFaceEntry = theSFace->GetID();
3020   }
3021   if (theFaceEntry.empty())
3022     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3023   
3024   if (theVertexEntry.empty()) {
3025     if (theVertex->GetShapeType() == GEOM::VERTEX)
3026       aName = "Vertex_";
3027     if (theVertex->GetShapeType() == GEOM::COMPOUND)
3028       aName = "Compound_";
3029     aName += theVertex->GetEntry();
3030     SALOMEDS::SObject_wrap theSVertex = geomGen->PublishInStudy(NULL, theVertex, aName.c_str());
3031     if (!theSVertex->_is_nil())
3032       theVertexEntry = theSVertex->GetID();
3033   }
3034   if (theVertexEntry.empty())
3035     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3036
3037   string theVertexName = theVertex->GetName();
3038   try {
3039     return SetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str());
3040   } catch (SALOME_Exception& ex) {
3041     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3042   }
3043 }
3044
3045 /*!
3046  * Set an enforced vertex with group name on face
3047  */
3048 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
3049 {
3050   ASSERT(myBaseImpl);
3051
3052   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
3053     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
3054   }
3055
3056   string theFaceEntry = theFace->GetStudyEntry();
3057   
3058   if (theFaceEntry.empty()) {
3059     GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3060     string aName;
3061     if (theFace->GetShapeType() == GEOM::FACE)
3062       aName = "Face_";
3063     if (theFace->GetShapeType() == GEOM::COMPOUND)
3064       aName = "Compound_";
3065     aName += theFace->GetEntry();
3066     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
3067     if (!theSFace->_is_nil())
3068       theFaceEntry = theSFace->GetID();
3069   }
3070   if (theFaceEntry.empty())
3071     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3072   try {
3073     return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, "", "", theGroupName);
3074   } catch (SALOME_Exception& ex) {
3075     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3076   }
3077 }
3078
3079 /*!
3080  * Set an enforced vertex with name and group name on face
3081  */
3082 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, 
3083                                                                 const char* theVertexName, const char* theGroupName)
3084 {
3085   ASSERT(myBaseImpl);
3086
3087   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
3088     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
3089   }
3090
3091   string theFaceEntry = theFace->GetStudyEntry();
3092   
3093   if (theFaceEntry.empty()) {
3094     GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3095     string aName;
3096     if (theFace->GetShapeType() == GEOM::FACE)
3097       aName = "Face_";
3098     if (theFace->GetShapeType() == GEOM::COMPOUND)
3099       aName = "Compound_";
3100     aName += theFace->GetEntry();
3101     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
3102     if (!theSFace->_is_nil())
3103       theFaceEntry = theSFace->GetID();
3104   }
3105   if (theFaceEntry.empty())
3106     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3107   try {
3108     return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, theVertexName, "", theGroupName);
3109   } catch (SALOME_Exception& ex) {
3110     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3111   }
3112 }
3113
3114 /*!
3115  * Set an enforced vertex with geom entry and group name on face
3116  */
3117 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
3118 {
3119   ASSERT(myBaseImpl);
3120
3121   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
3122     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
3123   }
3124
3125   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
3126     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
3127   }
3128
3129   string theFaceEntry = theFace->GetStudyEntry();
3130   string theVertexEntry = theVertex->GetStudyEntry();
3131   
3132   GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3133   string aName;
3134   
3135   if (theFaceEntry.empty()) {
3136     if (theFace->GetShapeType() == GEOM::FACE)
3137       aName = "Face_";
3138     if (theFace->GetShapeType() == GEOM::COMPOUND)
3139       aName = "Compound_";
3140     aName += theFace->GetEntry();
3141     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
3142     if (!theSFace->_is_nil())
3143       theFaceEntry = theSFace->GetID();
3144   }
3145   if (theFaceEntry.empty())
3146     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3147   
3148   if (theVertexEntry.empty()) {
3149     if (theVertex->GetShapeType() == GEOM::VERTEX)
3150       aName = "Vertex_";
3151     if (theVertex->GetShapeType() == GEOM::COMPOUND)
3152       aName = "Compound_";
3153     aName += theVertex->GetEntry();
3154     SALOMEDS::SObject_wrap theSVertex = geomGen->PublishInStudy(NULL, theVertex, aName.c_str());
3155     if (!theSVertex->_is_nil())
3156       theVertexEntry = theSVertex->GetID();
3157   }
3158   if (theVertexEntry.empty())
3159     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3160
3161   string theVertexName = theVertex->GetName();
3162   try {
3163     return SetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str(), theGroupName);
3164   } catch (SALOME_Exception& ex) {
3165     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3166   }
3167 }
3168
3169 //Enable internal enforced vertices on specific face if requested by user
3170 ///*!
3171 // * Are internal enforced vertices used for a face ?
3172 // */
3173 //CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace)
3174 //{
3175 //  ASSERT(myBaseImpl);
3176
3177 //  if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
3178 //    THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
3179 //  }
3180
3181 //  string theFaceEntry = theFace->GetStudyEntry();
3182   
3183 //  if (theFaceEntry.empty()) {
3184 //    GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3185 //    string aName;
3186 //    if (theFace->GetShapeType() == GEOM::FACE)
3187 //      aName = "Face_";
3188 //    if (theFace->GetShapeType() == GEOM::COMPOUND)
3189 //      aName = "Compound_";
3190 //    aName += theFace->GetEntry();
3191 //    SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
3192 //    if (!theSFace->_is_nil())
3193 //      theFaceEntry = theSFace->GetID();
3194 //  }
3195 //  if (theFaceEntry.empty())
3196 //    THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3197
3198 //  try {
3199 //    return GetInternalEnforcedVertexEntry(theFaceEntry.c_str());
3200 //  } catch (SALOME_Exception& ex) {
3201 //    THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3202 //  }
3203 //}
3204
3205 /*!
3206  * Get the list of all enforced vertices
3207  */
3208 BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEOM::GEOM_Object_ptr theFace)
3209 {
3210   ASSERT(myBaseImpl);
3211
3212   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
3213     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
3214   }
3215
3216   string theFaceEntry = theFace->GetStudyEntry();
3217   
3218   if (theFaceEntry.empty()) {
3219     GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3220     string aName;
3221     if (theFace->GetShapeType() == GEOM::FACE)
3222       aName = "Face_";
3223     if (theFace->GetShapeType() == GEOM::COMPOUND)
3224       aName = "Compound_";
3225     aName += theFace->GetEntry();
3226     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
3227     if (!theSFace->_is_nil())
3228       theFaceEntry = theSFace->GetID();
3229   }
3230   if (theFaceEntry.empty())
3231     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3232
3233   try {
3234     return GetEnforcedVerticesEntry(theFaceEntry.c_str());
3235   } catch (SALOME_Exception& ex) {
3236     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3237   }
3238 }
3239
3240 bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
3241                                                     CORBA::Double z) {
3242   ASSERT(myBaseImpl);
3243
3244   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
3245     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
3246   }
3247
3248   string theFaceEntry = theFace->GetStudyEntry();
3249   
3250   if (theFaceEntry.empty()) {
3251     GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3252     string aName;
3253     if (theFace->GetShapeType() == GEOM::FACE)
3254       aName = "Face_";
3255     if (theFace->GetShapeType() == GEOM::COMPOUND)
3256       aName = "Compound_";
3257     aName += theFace->GetEntry();
3258     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
3259     if (!theSFace->_is_nil())
3260       theFaceEntry = theSFace->GetID();
3261   }
3262   if (theFaceEntry.empty())
3263     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3264
3265   try {
3266     return UnsetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z);
3267   } catch (SALOME_Exception& ex) {
3268     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3269   }
3270 }
3271
3272 bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
3273 {
3274   ASSERT(myBaseImpl);
3275
3276   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
3277     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
3278   }
3279   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
3280     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
3281   }
3282
3283   //  GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3284   //  GEOM::GEOM_IMeasureOperations_var measureOp = geomGen->GetIMeasureOperations();
3285   //  if (CORBA::is_nil(measureOp))
3286   //    return false;
3287   //
3288   //  CORBA::Double x, y, z;
3289   //  x = y = z = 0.;
3290   //  measureOp->PointCoordinates(theVertex, x, y, z);
3291
3292   std::string theFaceEntry = theFace->GetStudyEntry();
3293   std::string theVertexEntry = theVertex->GetStudyEntry();
3294   
3295   GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3296   string aName;
3297   
3298   if (theFaceEntry.empty()) {
3299     if (theFace->GetShapeType() == GEOM::FACE)
3300       aName = "Face_";
3301     if (theFace->GetShapeType() == GEOM::COMPOUND)
3302       aName = "Compound_";
3303     aName += theFace->GetEntry();
3304     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
3305     if (!theSFace->_is_nil())
3306       theFaceEntry = theSFace->GetID();
3307   }
3308   if (theFaceEntry.empty())
3309     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3310   
3311   if (theVertexEntry.empty()) {
3312     if (theVertex->GetShapeType() == GEOM::VERTEX)
3313       aName = "Vertex_";
3314     if (theVertex->GetShapeType() == GEOM::COMPOUND)
3315       aName = "Compound_";
3316     aName += theVertex->GetEntry();
3317     SALOMEDS::SObject_wrap theSVertex = geomGen->PublishInStudy(NULL, theVertex, aName.c_str());
3318     if (!theSVertex->_is_nil())
3319       theVertexEntry = theSVertex->GetID();
3320   }
3321   if (theVertexEntry.empty())
3322     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3323   
3324
3325   try {
3326     return UnsetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexEntry.c_str());
3327   } catch (SALOME_Exception& ex) {
3328     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3329   }
3330 }
3331
3332 bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) {
3333   ASSERT(myBaseImpl);
3334
3335   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
3336     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
3337   }
3338
3339   string theFaceEntry = theFace->GetStudyEntry();
3340   
3341   if (theFaceEntry.empty()) {
3342     GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3343     string aName;
3344     if (theFace->GetShapeType() == GEOM::FACE)
3345       aName = "Face_";
3346     if (theFace->GetShapeType() == GEOM::COMPOUND)
3347       aName = "Compound_";
3348     aName += theFace->GetEntry();
3349     SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
3350     if (!theSFace->_is_nil())
3351       theFaceEntry = theSFace->GetID();
3352   }
3353   if (theFaceEntry.empty())
3354     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3355   
3356
3357   try {
3358     return UnsetEnforcedVerticesEntry(theFaceEntry.c_str());
3359   } catch (SALOME_Exception& ex) {
3360     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3361   }
3362 }
3363
3364 /*!
3365  * Set/get/unset an enforced vertex on face - NEW (no face)
3366  */
3367 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
3368 {
3369   ASSERT(myBaseImpl);
3370
3371   try {
3372     return SetEnforcedVertexEntry("", x, y, z);
3373   } catch (SALOME_Exception& ex) {
3374     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3375   }
3376 }
3377
3378 /*!
3379  * Set/get/unset an enforced vertex with name on face
3380  */
3381 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexName)
3382 {
3383   try {
3384     return SetEnforcedVertexEntry("", x, y, z, theVertexName);
3385   } catch (SALOME_Exception& ex) {
3386     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3387   }
3388 }
3389
3390 /*!
3391  * Set/get/unset an enforced vertex with geom object on face
3392  */
3393 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
3394 {
3395   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
3396     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
3397   }
3398   string theVertexEntry = theVertex->GetStudyEntry();
3399   
3400   GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theVertex );
3401   string aName;
3402   
3403   if (theVertexEntry.empty()) {
3404     if (theVertex->GetShapeType() == GEOM::VERTEX)
3405       aName = "Vertex_";
3406     if (theVertex->GetShapeType() == GEOM::COMPOUND)
3407       aName = "Compound_";
3408     aName += theVertex->GetEntry();
3409     SALOMEDS::SObject_wrap theSVertex = geomGen->PublishInStudy( NULL, theVertex, aName.c_str());
3410     if (!theSVertex->_is_nil())
3411       theVertexEntry = theSVertex->GetID();
3412   }
3413   if (theVertexEntry.empty())
3414     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3415
3416   string theVertexName = theVertex->GetName();
3417   try {
3418     return SetEnforcedVertexEntry("", 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str());
3419   } catch (SALOME_Exception& ex) {
3420     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3421   }
3422 }
3423
3424 /*!
3425  * Set an enforced vertex with group name on face
3426  */
3427 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
3428 {
3429   ASSERT(myBaseImpl);
3430
3431   try {
3432     return SetEnforcedVertexEntry("", x, y, z, "", "", theGroupName);
3433   } catch (SALOME_Exception& ex) {
3434     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3435   }
3436 }
3437
3438 /*!
3439  * Set an enforced vertex with name and group name on face
3440  */
3441 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, 
3442                                                                 const char* theVertexName, const char* theGroupName)
3443 {
3444   ASSERT(myBaseImpl);
3445
3446   try {
3447     return SetEnforcedVertexEntry("", x, y, z, theVertexName, "", theGroupName);
3448   } catch (SALOME_Exception& ex) {
3449     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3450   }
3451 }
3452
3453 /*!
3454  * Set an enforced vertex with geom entry and group name on face
3455  */
3456 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
3457 {
3458   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
3459     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
3460   }
3461
3462   string theVertexEntry = theVertex->GetStudyEntry();
3463   
3464   GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theVertex );
3465   string aName;
3466   
3467   if (theVertexEntry.empty()) {
3468     if (theVertex->GetShapeType() == GEOM::VERTEX)
3469       aName = "Vertex_";
3470     if (theVertex->GetShapeType() == GEOM::COMPOUND)
3471       aName = "Compound_";
3472     aName += theVertex->GetEntry();
3473     SALOMEDS::SObject_wrap theSVertex = geomGen->PublishInStudy( NULL, theVertex, aName.c_str());
3474     if (!theSVertex->_is_nil())
3475       theVertexEntry = theSVertex->GetID();
3476   }
3477   if (theVertexEntry.empty())
3478     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3479
3480   string theVertexName = theVertex->GetName();
3481   try {
3482     return SetEnforcedVertexEntry("", 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str(), theGroupName);
3483   } catch (SALOME_Exception& ex) {
3484     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3485   }
3486 }
3487
3488 bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
3489 {
3490   try {
3491     return UnsetEnforcedVertexEntry("", x, y, z);
3492   } catch (SALOME_Exception& ex) {
3493     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3494   }
3495 }
3496
3497 bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
3498 {
3499   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
3500     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
3501   }
3502   std::string theVertexEntry = theVertex->GetStudyEntry();
3503   
3504   GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theVertex );
3505   string aName;
3506   
3507   if (theVertexEntry.empty()) {
3508     if (theVertex->GetShapeType() == GEOM::VERTEX)
3509       aName = "Vertex_";
3510     if (theVertex->GetShapeType() == GEOM::COMPOUND)
3511       aName = "Compound_";
3512     aName += theVertex->GetEntry();
3513     SALOMEDS::SObject_wrap theSVertex = geomGen->PublishInStudy( NULL, theVertex, aName.c_str());
3514     if (!theSVertex->_is_nil())
3515       theVertexEntry = theSVertex->GetID();
3516   }
3517   if (theVertexEntry.empty())
3518     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3519   
3520   try {
3521     return UnsetEnforcedVertexEntry("", 0, 0, 0, theVertexEntry.c_str());
3522   } catch (SALOME_Exception& ex) {
3523     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3524   }
3525 }
3526
3527 bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertices()
3528 {
3529   try {
3530     return UnsetEnforcedVerticesEntry("");
3531   } catch (SALOME_Exception& ex) {
3532     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3533   }
3534 }
3535
3536 /*!
3537  * Set/get/unset an enforced vertex on geom object given by entry
3538  */
3539 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexEntry(const char* theFaceEntry,
3540                                                        CORBA::Double x,
3541                                                        CORBA::Double y,
3542                                                        CORBA::Double z,
3543                                                        const char* theVertexName,
3544                                                        const char* theVertexEntry,
3545                                                        const char* theGroupName)
3546 {
3547   bool newValue = false;
3548   if (string(theVertexEntry).empty()) {
3549     try {
3550       ::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList coordsList =
3551         this->GetImpl()->GetEnfVertexCoordsList(theFaceEntry);
3552       ::BLSURFPlugin_Hypothesis::TEnfVertexCoords coords;
3553       coords.push_back(x);
3554       coords.push_back(y);
3555       coords.push_back(z);
3556       if (coordsList.find(coords) == coordsList.end()) {
3557         newValue = true;
3558       } else {
3559         ::BLSURFPlugin_Hypothesis::TEnfVertex *enfVertex = this->GetImpl()->GetEnfVertex(coords);
3560         if ((enfVertex->name != theVertexName) || (enfVertex->grpName != theGroupName)) {
3561           newValue = true;
3562         }
3563       }
3564     } catch (const std::invalid_argument& ex) {
3565       // no enforced vertex for entry
3566       newValue = true;
3567     }
3568     if (newValue) {
3569       if (string(theVertexName).empty()) {
3570         if (string(theGroupName).empty())
3571           SMESH::TPythonDump() << _this() << ".AddEnforcedVertex(" << x << ", " << y << ", " << z << ")";
3572         else
3573           SMESH::TPythonDump() << _this() << ".AddEnforcedVertexWithGroup(" << x << ", " << y << ", " << z << ", \"" << theGroupName << "\")";
3574       }
3575       else {
3576         if (string(theGroupName).empty())
3577           SMESH::TPythonDump() << _this() << ".AddEnforcedVertexNamed(" << x << ", " << y << ", " << z << ", \"" << theVertexName << "\")";
3578         else
3579           SMESH::TPythonDump() << _this() << ".AddEnforcedVertexNamedWithGroup(" << x << ", " << y << ", " << z << ", \""
3580                                << theVertexName << "\", \"" << theGroupName << "\")";
3581       }
3582     }
3583   } else {
3584     try {
3585       ::BLSURFPlugin_Hypothesis::TEntryList enfVertexEntryList = this->GetImpl()->GetEnfVertexEntryList(theFaceEntry);
3586       ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it = enfVertexEntryList.find(theVertexEntry);
3587       if ( it == enfVertexEntryList.end()) {
3588         newValue = true;
3589       }
3590       else {
3591         ::BLSURFPlugin_Hypothesis::TEnfVertex *enfVertex = this->GetImpl()->GetEnfVertex((*it));
3592         if ((enfVertex->name != theVertexName) || (enfVertex->grpName != theGroupName)) {
3593           newValue = true;
3594         }
3595       }
3596     } catch (const std::invalid_argument& ex) {
3597       // no enforced vertex for entry
3598       newValue = true;
3599     }
3600     if (newValue) {
3601       if (string(theGroupName).empty())
3602         SMESH::TPythonDump() << _this() << ".AddEnforcedVertexGeom(" << theVertexEntry << ")";
3603       else
3604         SMESH::TPythonDump() << _this() << ".AddEnforcedVertexGeomWithGroup(" << theVertexEntry << ", \"" << theGroupName << "\")";
3605     }
3606   }
3607
3608   if (newValue)
3609     this->GetImpl()->SetEnforcedVertex(theFaceEntry, theVertexName, theVertexEntry, theGroupName, x, y, z);
3610
3611   return newValue;
3612 }
3613
3614 BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntry(const char* entry)
3615 {
3616   try {
3617     BLSURFPlugin::TEnfVertexList_var vertexList = new BLSURFPlugin::TEnfVertexList();
3618     ::BLSURFPlugin_Hypothesis::TEnfVertexList _vList = this->GetImpl()->GetEnfVertexList(entry);
3619     vertexList->length((CORBA::ULong) _vList.size());
3620     ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = _vList.begin();
3621     for (int i = 0; evlIt != _vList.end(); ++evlIt, ++i) {
3622       ::BLSURFPlugin_Hypothesis::TEnfVertex *_enfVertex = (*evlIt);
3623
3624       BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
3625
3626       // Name
3627       enfVertex->name = CORBA::string_dup(_enfVertex->name.c_str());
3628       // Geom Vertex Entry
3629       enfVertex->geomEntry = CORBA::string_dup(_enfVertex->geomEntry.c_str());
3630       // Coords
3631       BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
3632       coords->length((CORBA::ULong) _enfVertex->coords.size());
3633       for ( CORBA::ULong ind = 0; ind < coords->length(); ind++ )
3634         coords[ind] = _enfVertex->coords[ind];
3635       enfVertex->coords = coords;
3636       // Group Name
3637       enfVertex->grpName = CORBA::string_dup(_enfVertex->grpName.c_str());
3638       // Face entry list
3639       BLSURFPlugin::TEntryList_var faceEntryList = new BLSURFPlugin::TEntryList();
3640       faceEntryList->length((CORBA::ULong) _enfVertex->faceEntries.size());
3641       ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_entry = _enfVertex->faceEntries.begin();
3642       for (int ind = 0; it_entry != _enfVertex->faceEntries.end();++it_entry, ++ind)
3643         faceEntryList[ind] = CORBA::string_dup((*it_entry).c_str());
3644       enfVertex->faceEntries = faceEntryList;
3645
3646       vertexList[i] = enfVertex;
3647     }
3648     return vertexList._retn();
3649   } catch (const std::invalid_argument& ex) {
3650     SALOME::ExceptionStruct ExDescription;
3651     ExDescription.text = ex.what();
3652     ExDescription.type = SALOME::BAD_PARAM;
3653     ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntry(entry)";
3654     ExDescription.lineNumber = 1385;
3655     throw SALOME::SALOME_Exception(ExDescription);
3656   } catch (const std::exception& ex) {
3657     std::cout << "Exception: " << ex.what() << std::endl;
3658     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3659   }
3660 }
3661
3662 bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexEntry)
3663 {
3664   ASSERT(myBaseImpl);
3665
3666   bool res = false;
3667   try {
3668     res = this->GetImpl()->ClearEnforcedVertex(theFaceEntry, x, y, z, theVertexEntry);
3669
3670     if (string(theVertexEntry).empty())
3671       SMESH::TPythonDump() << "isDone = " << _this() << ".RemoveEnforcedVertex(" << x << ", " << y << ", " << z
3672                            << ")";
3673     else
3674       SMESH::TPythonDump() << "isDone = " << _this() << ".RemoveEnforcedVertexGeom(" << theVertexEntry << ")";
3675
3676   } catch (const std::invalid_argument& ex) {
3677     return false;
3678   } catch (const std::exception& ex) {
3679     std::cout << "Exception: " << ex.what() << std::endl;
3680     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3681   }
3682
3683   return res;
3684 }
3685 bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(const char* theFaceEntry)
3686 {
3687   ASSERT(myBaseImpl);
3688
3689   try {
3690     this->GetImpl()->ClearEnforcedVertices(theFaceEntry);
3691     SMESH::TPythonDump() << _this() << ".RemoveEnforcedVertices()";
3692   } catch (const std::invalid_argument& ex) {
3693     return false;
3694   } catch (const std::exception& ex) {
3695     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3696   }
3697
3698   return true;
3699 }
3700
3701 //=============================================================================
3702 /*!
3703  *  BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFaces
3704  *
3705  *  Set true or false
3706  */
3707 //=============================================================================
3708 void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFaces(CORBA::Boolean theValue)
3709 {
3710   ASSERT(myBaseImpl);
3711   this->GetImpl()->SetInternalEnforcedVertexAllFaces(theValue);
3712   std::string theValueStr = theValue ? "True" : "False";
3713   SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertexAllFaces( " << theValueStr.c_str() << " )";
3714 }
3715
3716 //=============================================================================
3717 /*!
3718  *  BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFaces
3719  *
3720  *  Get true or false
3721  */
3722 //=============================================================================
3723 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFaces()
3724 {
3725   ASSERT(myBaseImpl);
3726   return this->GetImpl()->_GetInternalEnforcedVertexAllFaces();
3727 }
3728
3729 //=============================================================================
3730 /*!
3731  *  BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFacesGroup
3732  *
3733  *  Set group name
3734  */
3735 //=============================================================================
3736 void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFacesGroup(const char*  groupName)
3737 {
3738   ASSERT(myBaseImpl);
3739   this->GetImpl()->SetInternalEnforcedVertexAllFacesGroup(groupName);
3740   SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertexAllFacesGroup( \"" << groupName << "\" )";
3741 }
3742
3743 //=============================================================================
3744 /*!
3745  *  BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup
3746  *
3747  *  Get group name
3748  */
3749 //=============================================================================
3750 char* BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup()
3751 {
3752   ASSERT(myBaseImpl);
3753   return CORBA::string_dup(this->GetImpl()->_GetInternalEnforcedVertexAllFacesGroup().c_str());
3754 }
3755
3756 /*
3757  * Enable internal enforced vertices on specific face if requested by user
3758  *
3759  void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices)
3760  {
3761  try {
3762  SetInternalEnforcedVertexWithGroup(theFace, toEnforceInternalVertices);
3763  } catch (SALOME_Exception& ex) {
3764  THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3765  }
3766  }
3767
3768  void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
3769  {
3770  if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
3771  THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
3772  }
3773
3774  string theFaceEntry = theFace->GetStudyEntry();
3775
3776  if (theFaceEntry.empty()) {
3777  GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( theFace );
3778  SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen();
3779  string aName;
3780  if (theFace->GetShapeType() == GEOM::FACE)
3781  aName = "Face_";
3782  if (theFace->GetShapeType() == GEOM::COMPOUND)
3783  aName = "Compound_";
3784  aName += theFace->GetEntry();
3785  SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(NULL, theFace, aName.c_str());
3786  if (!theSFace->_is_nil())
3787  theFaceEntry = theSFace->GetID();
3788  }
3789  if (theFaceEntry.empty())
3790  THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3791
3792  try {
3793  SetInternalEnforcedVertexEntry(theFaceEntry.c_str(), toEnforceInternalVertices, theGroupName);
3794  } catch (SALOME_Exception& ex) {
3795  THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3796  }
3797  }
3798
3799  void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexEntry(const char* theFaceEntry, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
3800  {
3801  ASSERT(myBaseImpl);
3802  try {
3803  this->GetImpl()->SetInternalEnforcedVertex(theFaceEntry, toEnforceInternalVertices, theGroupName);
3804  std::string theValueStr = toEnforceInternalVertices ? "True" : "False";
3805  if (string(theGroupName).empty())
3806  SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertex( " << theFaceEntry << ", " << theValueStr.c_str() << " )";
3807  else
3808  SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertexWithGroup( " << theFaceEntry << ", " << theValueStr.c_str() << ", \"" << theGroupName << "\" )";
3809  } catch (const std::exception& ex) {
3810  std::cout << "Exception: " << ex.what() << std::endl;
3811  THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3812  }
3813  }
3814
3815 */
3816
3817 /* TODO GROUPS
3818    char* BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z)
3819    
3820    {
3821    ASSERT(myBaseImpl);
3822    try {
3823    return CORBA::string_dup( this->GetImpl()->GetEnforcedVertexGroupName(x, y, z).c_str());
3824    }
3825    catch (const std::invalid_argument& ex) {
3826    SALOME::ExceptionStruct ExDescription;
3827    ExDescription.text = ex.what();
3828    ExDescription.type = SALOME::BAD_PARAM;
3829    ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(entry)";
3830    ExDescription.lineNumber = 1146;
3831    throw SALOME::SALOME_Exception(ExDescription);
3832    }
3833    catch (SALOME_Exception& ex) {
3834    THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3835    }
3836    return 0;
3837    }
3838
3839
3840    void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName)
3841    {
3842    ASSERT(myBaseImpl);
3843    try {
3844    this->GetImpl()->SetEnforcedVertexGroupName(x, y, z, groupName);
3845    }
3846    catch (const std::invalid_argument& ex) {
3847    SALOME::ExceptionStruct ExDescription;
3848    ExDescription.text = ex.what();
3849    ExDescription.type = SALOME::BAD_PARAM;
3850    ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetEnforcedVertexGroupName(x,y,z)";
3851    ExDescription.lineNumber = 1170;
3852    throw SALOME::SALOME_Exception(ExDescription);
3853    }
3854    catch (SALOME_Exception& ex) {
3855    THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
3856    }
3857
3858    SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGroupName("
3859    << x << ", " << y << ", " << z << ", '" << groupName << "' )";
3860
3861    }
3862 */
3863 ///////////////////////
3864
3865 ///////////////////////
3866 // PERIODICITY       //
3867 ///////////////////////
3868
3869
3870 std::string BLSURFPlugin_Hypothesis_i::ShapeTypeToString(GEOM::shape_type theShapeType)
3871 {
3872   std::map<GEOM::shape_type, std::string> MapShapeTypeToString;
3873   MapShapeTypeToString[GEOM::COMPOUND] = std::string("COMPOUND");
3874   MapShapeTypeToString[GEOM::COMPSOLID] = std::string("COMPSOLID");
3875   MapShapeTypeToString[GEOM::SOLID] = std::string("SOLID");
3876   MapShapeTypeToString[GEOM::SHELL] = std::string("SHELL");
3877   MapShapeTypeToString[GEOM::FACE] = std::string("FACE");
3878   MapShapeTypeToString[GEOM::WIRE] = std::string("WIRE");
3879   MapShapeTypeToString[GEOM::EDGE] = std::string("EDGE");
3880   MapShapeTypeToString[GEOM::VERTEX] = std::string("VERTEX");
3881   MapShapeTypeToString[GEOM::SHAPE] = std::string("SHAPE");
3882   std::string txtShapeType = MapShapeTypeToString[theShapeType];
3883   return txtShapeType;
3884 }
3885
3886 void BLSURFPlugin_Hypothesis_i::CheckShapeTypes(GEOM::GEOM_Object_ptr shape, std::vector<GEOM::shape_type> theShapeTypes)
3887 {
3888   // Check shape types
3889   bool ok = false;
3890   std::stringstream typesTxt;
3891   for (std::size_t i=0; i<theShapeTypes.size(); i++)
3892   {
3893     GEOM::shape_type theShapeType = theShapeTypes[i];
3894     if (shape->GetShapeType() == theShapeType)
3895       ok = true;
3896     typesTxt << ShapeTypeToString(theShapeType);
3897     if (i < theShapeTypes.size()-1 )
3898       typesTxt << ", ";
3899   }
3900   if (!ok)
3901   {
3902     std::stringstream msg;
3903     msg << "shape type is not in" << typesTxt.str();
3904     THROW_SALOME_CORBA_EXCEPTION(msg.str().c_str(), SALOME::BAD_PARAM);
3905   }
3906 }
3907
3908 void BLSURFPlugin_Hypothesis_i::CheckShapeType(GEOM::GEOM_Object_ptr shape, GEOM::shape_type theShapeType)
3909 {
3910   // Check shape type
3911   if (shape->GetShapeType() != theShapeType) {
3912     std::stringstream msg;
3913     msg << "shape shape type is not " << ShapeTypeToString(theShapeType);
3914     THROW_SALOME_CORBA_EXCEPTION(msg.str().c_str(), SALOME::BAD_PARAM);
3915   }
3916 }
3917
3918 std::string BLSURFPlugin_Hypothesis_i::PublishIfNeeded(GEOM::GEOM_Object_ptr shape, GEOM::shape_type theShapeType, std::string prefix)
3919 {
3920   // Check shape is published in the object browser
3921   string shapeEntry = shape->GetStudyEntry();
3922
3923   GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine( shape );
3924   string aName;
3925
3926   // Publish shape if needed
3927   if (shapeEntry.empty()) {
3928     if (shape->GetShapeType() == theShapeType)
3929       aName = prefix;
3930     aName += shape->GetEntry();
3931     SALOMEDS::SObject_wrap theSFace1 = geomGen->PublishInStudy(NULL, shape, aName.c_str());
3932     if (!theSFace1->_is_nil())
3933       shapeEntry = theSFace1->GetID();
3934   }
3935   if (shapeEntry.empty())
3936     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
3937   return shapeEntry;
3938 }
3939
3940 // Format the output of two vectors to use it in MESSAGE and PythonDump
3941 std::string BLSURFPlugin_Hypothesis_i::FormatVerticesEntries(vector<string> &theSourceVerticesEntries, vector<string> &theTargetVerticesEntries)
3942 {
3943   std::stringstream listEntriesTxt;
3944
3945   if (!theSourceVerticesEntries.empty())
3946   {
3947     listEntriesTxt << ", [" ;
3948     size_t i =0;
3949     for (std::vector<std::string>::const_iterator it = theSourceVerticesEntries.begin(); it != theSourceVerticesEntries.end(); it++, i++)
3950     {
3951       if (i>0)
3952         listEntriesTxt << ", ";
3953       listEntriesTxt << *it;
3954     }
3955
3956     listEntriesTxt << "], [" ;
3957     i =0;
3958     for (std::vector<std::string>::const_iterator it = theTargetVerticesEntries.begin(); it != theTargetVerticesEntries.end(); it++, i++)
3959     {
3960       if (i>0)
3961         listEntriesTxt << ", ";
3962       listEntriesTxt << *it;
3963     }
3964     listEntriesTxt << "]" ;
3965   }
3966   return listEntriesTxt.str();
3967 }
3968
3969 /**
3970  * Erase all PreCad periodicity associations
3971  */
3972 void BLSURFPlugin_Hypothesis_i::ClearPreCadPeriodicityVectors() {
3973   ASSERT(myBaseImpl);
3974   this->GetImpl()->ClearPreCadPeriodicityVectors();
3975   SMESH::TPythonDump() << _this() << ".ClearPreCadPeriodicityVectors()";
3976 }
3977
3978 BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::GetPreCadFacesPeriodicityVector()
3979 {
3980   const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector preCadPeriodicityVector =
3981     this->GetImpl()->_GetPreCadFacesPeriodicityVector();
3982
3983   BLSURFPlugin::TPeriodicityList_var periodicityList = PreCadVectorToSequence(preCadPeriodicityVector);
3984
3985   return periodicityList._retn();
3986 }
3987
3988 BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::GetPreCadEdgesPeriodicityVector()
3989 {
3990   const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector preCadPeriodicityVector =
3991     this->GetImpl()->_GetPreCadEdgesPeriodicityVector();
3992
3993   BLSURFPlugin::TPeriodicityList_var periodicityList = PreCadVectorToSequence(preCadPeriodicityVector);
3994
3995   return periodicityList._retn();
3996 }
3997
3998 // convert a vector preCadPeriodicityVector into TPeriodicityList Corba sequence
3999 BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::PreCadVectorToSequence(const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector& preCadPeriodicityVector)
4000 {
4001   BLSURFPlugin::TPeriodicityList_var periodicityList = new BLSURFPlugin::TPeriodicityList();
4002
4003   periodicityList->length((CORBA::ULong) preCadPeriodicityVector.size());
4004
4005   for ( CORBA::ULong i = 0; i<preCadPeriodicityVector.size(); i++)
4006   {
4007     ::BLSURFPlugin_Hypothesis::TPreCadPeriodicity preCadPeriodicityVector_i = preCadPeriodicityVector[i];
4008
4009     BLSURFPlugin::TPreCadPeriodicity_var myPreCadPeriodicity = new BLSURFPlugin::TPreCadPeriodicity();
4010     myPreCadPeriodicity->shape1Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape1Entry.c_str());
4011     myPreCadPeriodicity->shape2Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape2Entry.c_str());
4012
4013     BLSURFPlugin::TEntryList_var sourceVertices = new BLSURFPlugin::TEntryList();
4014     if (! preCadPeriodicityVector_i.theSourceVerticesEntries.empty())
4015     {
4016       sourceVertices->length((CORBA::ULong) preCadPeriodicityVector_i.theSourceVerticesEntries.size());
4017       for (CORBA::ULong j=0; j<preCadPeriodicityVector_i.theSourceVerticesEntries.size(); j++)
4018         sourceVertices[j]=CORBA::string_dup(preCadPeriodicityVector_i.theSourceVerticesEntries[j].c_str());
4019     }
4020
4021     myPreCadPeriodicity->theSourceVerticesEntries = sourceVertices;
4022
4023     BLSURFPlugin::TEntryList_var targetVertices = new BLSURFPlugin::TEntryList();
4024     if (! preCadPeriodicityVector_i.theTargetVerticesEntries.empty())
4025     {
4026       targetVertices->length((CORBA::ULong) preCadPeriodicityVector_i.theTargetVerticesEntries.size());
4027       for (CORBA::ULong j=0; j<preCadPeriodicityVector_i.theTargetVerticesEntries.size(); j++)
4028         targetVertices[j]=CORBA::string_dup(preCadPeriodicityVector_i.theTargetVerticesEntries[j].c_str());
4029     }
4030
4031     myPreCadPeriodicity->theTargetVerticesEntries = targetVertices;
4032
4033     periodicityList[i] = myPreCadPeriodicity;
4034   }
4035
4036
4037   return periodicityList._retn();
4038 }
4039
4040
4041 void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicity(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2)
4042 {
4043   ASSERT(myBaseImpl);
4044   const GEOM::ListOfGO theSourceVertices;
4045   const GEOM::ListOfGO theTargetVertices;
4046   AddPreCadFacesPeriodicityWithVertices(theFace1, theFace2, theSourceVertices, theTargetVertices);
4047 }
4048
4049
4050 void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2,
4051                                                                       const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
4052 {
4053   ASSERT(myBaseImpl);
4054
4055   size_t theLength = theSourceVertices.length();
4056   if (theLength != theTargetVertices.length())
4057     THROW_SALOME_CORBA_EXCEPTION( "The sizes of theSourceVertices and theTargetVertices must be the same" ,SALOME::BAD_PARAM );
4058
4059   std::vector<GEOM::shape_type> allowedShapeTypes;
4060   allowedShapeTypes.push_back(GEOM::FACE);
4061   allowedShapeTypes.push_back(GEOM::COMPOUND);
4062
4063   string prefix1 = "Source_face_";
4064   CheckShapeTypes(theFace1, allowedShapeTypes);
4065   string theFace1Entry = PublishIfNeeded(theFace1, GEOM::FACE, prefix1);
4066
4067   string prefix2 = "Target_face_";
4068   CheckShapeTypes(theFace2, allowedShapeTypes);
4069   string theFace2Entry = PublishIfNeeded(theFace2, GEOM::FACE, prefix2);
4070
4071   string prefix3 = "Source_vertex_";
4072   BLSURFPlugin::TEntryList_var theSourceVerticesEntries = new BLSURFPlugin::TEntryList();
4073   theSourceVerticesEntries->length((CORBA::ULong) theLength);
4074   GEOM::GEOM_Object_ptr theVtx_i;
4075   string theEntry_i;
4076   for (CORBA::ULong ind = 0; ind < theLength; ind++) {
4077     theVtx_i = theSourceVertices[ind];
4078     theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3);
4079     theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
4080   }
4081
4082   string prefix4 = "Target_vertex_";
4083   BLSURFPlugin::TEntryList_var theTargetVerticesEntries = new BLSURFPlugin::TEntryList();
4084   theTargetVerticesEntries->length((CORBA::ULong) theLength);
4085   for ( CORBA::ULong  ind = 0; ind < theLength; ind++) {
4086     theVtx_i = theTargetVertices[ind];
4087     theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4);
4088     theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
4089   }
4090
4091   string theFace2Name = theFace2->GetName();
4092   try {
4093     AddPreCadFacesPeriodicityEntry(theFace1Entry.c_str(), theFace2Entry.c_str(),
4094                                    theSourceVerticesEntries, theTargetVerticesEntries);
4095   } catch (SALOME_Exception& ex) {
4096     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
4097   }
4098 }
4099
4100
4101 void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityEntry(const char* theFace1Entry, const char* theFace2Entry,
4102                                                                const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
4103 {
4104   ASSERT(myBaseImpl);
4105
4106   // Convert BLSURFPlugin::TEntryList to vector<string>
4107   vector<string> theSourceVerticesEntries, theTargetVerticesEntries;
4108   for ( CORBA::ULong  ind = 0; ind < theSourceVerticesEntriesCorba.length(); ind++) {
4109     theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in());
4110     theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in());
4111   }
4112
4113   string listEntriesTxt = FormatVerticesEntries(theSourceVerticesEntries, theTargetVerticesEntries);
4114
4115
4116   this->GetImpl()->AddPreCadFacesPeriodicity(theFace1Entry, theFace2Entry,
4117                                              theSourceVerticesEntries, theTargetVerticesEntries);
4118
4119   SMESH::TPythonDump pd;
4120   if (!theSourceVerticesEntries.empty())
4121   {
4122     pd << _this() << ".AddPreCadFacesPeriodicityWithVertices(" << theFace1Entry << ", " << theFace2Entry;
4123     pd << listEntriesTxt.c_str();
4124     pd << ")";
4125   }
4126   else
4127     pd << _this() << ".AddPreCadFacesPeriodicity(" << theFace1Entry << ", " << theFace2Entry << ")";
4128 }
4129
4130 void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicity(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2)
4131 {
4132   ASSERT(myBaseImpl);
4133   const GEOM::ListOfGO theSourceVertices;
4134   const GEOM::ListOfGO theTargetVertices;
4135   AddPreCadEdgesPeriodicityWithVertices(theEdge1, theEdge2, theSourceVertices, theTargetVertices);
4136 }
4137
4138 void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2,
4139                                                                       const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
4140 {
4141   ASSERT(myBaseImpl);
4142
4143   size_t theLength = theSourceVertices.length();
4144   if (theLength != theTargetVertices.length())
4145     THROW_SALOME_CORBA_EXCEPTION( "The sizes of theSourceVertices and theTargetVertices must be the same" ,SALOME::BAD_PARAM );
4146
4147   std::vector<GEOM::shape_type> allowedShapeTypes;
4148   allowedShapeTypes.push_back(GEOM::EDGE);
4149   allowedShapeTypes.push_back(GEOM::COMPOUND);
4150
4151   string prefix1 = "Source_edge_";
4152   CheckShapeTypes(theEdge1, allowedShapeTypes);
4153   string theEdge1Entry = PublishIfNeeded(theEdge1, GEOM::EDGE, prefix1);
4154
4155   string prefix2 = "Target_edge_";
4156   CheckShapeTypes(theEdge2, allowedShapeTypes);
4157   string theEdge2Entry = PublishIfNeeded(theEdge2, GEOM::EDGE, prefix2);
4158
4159   string prefix3 = "Source_vertex_";
4160   BLSURFPlugin::TEntryList_var theSourceVerticesEntries = new BLSURFPlugin::TEntryList();
4161   theSourceVerticesEntries->length((CORBA::ULong) theLength);
4162   GEOM::GEOM_Object_ptr theVtx_i;
4163   string theEntry_i;
4164   for (CORBA::ULong ind = 0; ind < theLength; ind++) {
4165     theVtx_i = theSourceVertices[ind];
4166     theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3);
4167     theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
4168   }
4169
4170   string prefix4 = "Target_vertex_";
4171   BLSURFPlugin::TEntryList_var theTargetVerticesEntries = new BLSURFPlugin::TEntryList();
4172   theTargetVerticesEntries->length((CORBA::ULong) theLength);
4173   for (CORBA::ULong ind = 0; ind < theLength; ind++) {
4174     theVtx_i = theTargetVertices[ind];
4175     theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4);
4176     theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
4177   }
4178
4179   string theEdge2Name = theEdge2->GetName();
4180   try {
4181     AddPreCadEdgesPeriodicityEntry(theEdge1Entry.c_str(), theEdge2Entry.c_str(),
4182                                    theSourceVerticesEntries, theTargetVerticesEntries);
4183   } catch (SALOME_Exception& ex) {
4184     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
4185   }
4186 }
4187
4188
4189 void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityEntry(const char* theEdge1Entry, const char* theEdge2Entry,
4190                                                                const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
4191 {
4192
4193   ASSERT(myBaseImpl);
4194
4195   // Convert BLSURFPlugin::TEntryList to vector<string>
4196   vector<string> theSourceVerticesEntries, theTargetVerticesEntries;
4197   for (CORBA::ULong  ind = 0; ind < theSourceVerticesEntriesCorba.length(); ind++) {
4198     theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in());
4199     theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in());
4200   }
4201
4202   string listEntriesTxt = FormatVerticesEntries(theSourceVerticesEntries, theTargetVerticesEntries);
4203
4204   this->GetImpl()->AddPreCadEdgesPeriodicity(theEdge1Entry, theEdge2Entry,
4205                                              theSourceVerticesEntries, theTargetVerticesEntries);
4206
4207   SMESH::TPythonDump pd;
4208   if (!theSourceVerticesEntries.empty())
4209   {
4210     pd << _this() << ".AddPreCadEdgesPeriodicityWithVertices(" << theEdge1Entry << ", " << theEdge2Entry;
4211     pd << listEntriesTxt.c_str();
4212     pd << ")";
4213   }
4214   else
4215     pd << _this() << ".AddPreCadEdgesPeriodicity(" << theEdge1Entry << ", " << theEdge2Entry << ")";
4216
4217 }
4218
4219
4220 //================================================================================
4221 /*!
4222  * \brief Sets the file for export resulting mesh in GMF format
4223  * \param theFileName - full name of the file (.mesh, .meshb)
4224  * 
4225  * After compute, export the resulting mesh in the given file with the GMF format (.mesh)
4226  */
4227 //================================================================================  
4228 // void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName, CORBA::Boolean isBinary) {
4229 void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName) {
4230   ASSERT(myBaseImpl);
4231   bool valueChanged/*, modeChanged*/ = false;
4232   try {
4233     valueChanged = (this->GetImpl()->GetGMFFile() != theFileName);
4234     //     modeChanged = (this->GetImpl()->GetGMFFileMode() != isBinary);
4235     if (valueChanged)// or (!valueChanged && modeChanged))
4236       this->GetImpl()->SetGMFFile(theFileName);// ,isBinary);
4237   } catch (const std::exception& ex) {
4238     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
4239   }
4240   if (valueChanged)// or (!valueChanged && modeChanged))
4241     SMESH::TPythonDump() << _this() << ".SetGMFFile(\"" << theFileName << "\")"; //", " << isBinary << ")";
4242 }
4243
4244 //================================================================================
4245 /*!
4246  * \brief Gets the file name for export resulting mesh in GMF format
4247  * \retval char* - The file name
4248  * 
4249  * Returns the GMF file name
4250  */
4251 //================================================================================  
4252 char* BLSURFPlugin_Hypothesis_i::GetGMFFile() {
4253   ASSERT(myBaseImpl);
4254   return CORBA::string_dup(this->GetImpl()->GetGMFFile().c_str());
4255 }
4256
4257 // //================================================================================
4258 // /*!
4259 //  * \brief Gets the file mode for export resulting mesh in GMF format
4260 //  * \retval CORBA::Boolean - TRUE if binary mode, FALSE if ascii mode
4261 //  * 
4262 //  * Returns the GMF file mode
4263 //  */
4264 // //================================================================================  
4265 // CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetGMFFileMode() {
4266 //   ASSERT(myBaseImpl);
4267 //   return this->GetImpl()->GetGMFFileMode();
4268 // }
4269
4270 //=============================================================================
4271 /*!
4272  *  BLSURFPlugin_Hypothesis_i::GetImpl
4273  *
4274  *  Get implementation
4275  */
4276 //=============================================================================
4277 ::BLSURFPlugin_Hypothesis* BLSURFPlugin_Hypothesis_i::GetImpl() {
4278   return (::BLSURFPlugin_Hypothesis*) myBaseImpl;
4279 }
4280
4281 //================================================================================
4282 /*!
4283  * \brief Verify whether hypothesis supports given entity type
4284  * \param type - dimension (see SMESH::Dimension enumeration)
4285  * \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
4286  *
4287  * Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
4288  */
4289 //================================================================================
4290 CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsDimSupported(SMESH::Dimension type) {
4291   return type == SMESH::DIM_2D;
4292 }
4293
4294
4295 //================================================================================
4296 /*!
4297  * \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
4298  */
4299 //================================================================================
4300
4301 bool
4302 BLSURFPlugin_Hypothesis_i::getObjectsDependOn( std::vector< std::string > & entryArray,
4303                                                std::vector< int >         & subIDArray ) const
4304 {
4305   typedef ::BLSURFPlugin_Hypothesis BH;
4306   const BH* impl = static_cast<const BH*>( myBaseImpl );
4307
4308   {
4309     const BH::TSizeMap& sizeMap = impl->_GetSizeMapEntries();
4310     BH::TSizeMap::const_iterator entry2size = sizeMap.cbegin();
4311     for ( ; entry2size != sizeMap.cend(); ++entry2size )
4312       entryArray.push_back( entry2size->first );
4313   }
4314   {
4315     const BH::TSizeMap& sizeMap = impl->_GetAttractorEntries();
4316     BH::TSizeMap::const_iterator entry2size = sizeMap.cbegin();
4317     for ( ; entry2size != sizeMap.cend(); ++entry2size )
4318       entryArray.push_back( entry2size->first );
4319   }
4320   {
4321     const BH::TAttractorMap& classAttractors = impl-> _GetClassAttractorEntries();
4322     BH::TAttractorMap::const_iterator entry2size = classAttractors.cbegin();
4323     for ( ; entry2size != classAttractors.cend(); ++entry2size )
4324       entryArray.push_back( entry2size->first );
4325   }
4326   {
4327     const BH::TFaceEntryEnfVertexListMap& faceEntryEnfVertexListMap = impl->_GetAllEnforcedVerticesByFace();
4328     BH::TFaceEntryEnfVertexListMap::const_iterator entry2evList = faceEntryEnfVertexListMap.cbegin();
4329     for ( ; entry2evList != faceEntryEnfVertexListMap.cend(); ++entry2evList )
4330     {
4331       entryArray.push_back( entry2evList->first );
4332
4333       const BH::TEnfVertexList& evList = entry2evList->second;
4334       BH::TEnfVertexList::const_iterator evIt = evList.cbegin();
4335       for ( ; evIt != evList.cend(); ++evIt )
4336       {
4337         const BH::TEnfVertex* ev = *evIt;
4338         entryArray.push_back( ev->geomEntry );
4339         entryArray.insert( entryArray.end(), ev->faceEntries.cbegin(), ev->faceEntries.cend() );
4340       }
4341     }
4342   }
4343   // { // duplicated data of faceEntryEnfVertexListMap
4344   //   const BH::TEnfVertexList& enfVertexList = impl->_GetAllEnforcedVertices();
4345   //   const BH::TFaceEntryCoordsListMap& faceEntryCoordsListMap = impl->_GetAllCoordsByFace();
4346   //   const BH::TFaceEntryEnfVertexEntryListMap& faceEntryEnfVertexEntryListMap = impl->_GetAllEnfV  //   const BH::TEnfVertexEntryEnfVertexMap& enfVertexEntryEnfVertexMap = impl->_GetAllEnforcedVert  // }
4347   {
4348     const BH::TPreCadPeriodicityVector& preCadFacesPeriodicityVector = impl->_GetPreCadFacesPeriodicityVector();
4349     BH::TPreCadPeriodicityVector::const_iterator pcp = preCadFacesPeriodicityVector.cbegin();
4350     for ( ; pcp != preCadFacesPeriodicityVector.cend(); ++pcp )
4351     {
4352       entryArray.push_back( pcp->shape1Entry );
4353       entryArray.push_back( pcp->shape2Entry );
4354       entryArray.insert( entryArray.end(),
4355                          pcp->theSourceVerticesEntries.cbegin(),
4356                          pcp->theSourceVerticesEntries.cend() );
4357       entryArray.insert( entryArray.end(),
4358                          pcp->theTargetVerticesEntries.cbegin(),
4359                          pcp->theTargetVerticesEntries.cend() );
4360     }
4361   }
4362   {
4363     const BH::TPreCadPeriodicityVector& preCadEdgesPeriodicityVector = impl->_GetPreCadEdgesPeriodicityVector();
4364     BH::TPreCadPeriodicityVector::const_iterator pcp = preCadEdgesPeriodicityVector.cbegin();
4365     for ( ; pcp != preCadEdgesPeriodicityVector.cend(); ++pcp )
4366     {
4367       entryArray.push_back( pcp->shape1Entry );
4368       entryArray.push_back( pcp->shape2Entry );
4369       entryArray.insert( entryArray.end(),
4370                          pcp->theSourceVerticesEntries.cbegin(),
4371                          pcp->theSourceVerticesEntries.cend() );
4372       entryArray.insert( entryArray.end(),
4373                          pcp->theTargetVerticesEntries.cbegin(),
4374                          pcp->theTargetVerticesEntries.cend() );
4375     }
4376   }
4377   {
4378     const BH::THyperPatchList& hyperPatchList = impl->GetHyperPatches();
4379     BH::THyperPatchList::const_iterator idSet = hyperPatchList.cbegin();
4380     for ( ; idSet != hyperPatchList.cend(); ++idSet )
4381     {
4382       subIDArray.insert( subIDArray.end(), idSet->cbegin(), idSet->cend() );
4383     }
4384   }
4385   return true;
4386 }
4387
4388 //================================================================================
4389 /*!
4390  * \brief Set new geometry instead of that returned by getObjectsDependOn()
4391  */
4392 //================================================================================
4393
4394 bool
4395 BLSURFPlugin_Hypothesis_i::setObjectsDependOn( std::vector< std::string > & entryArray,
4396                                                std::vector< int >         & subIDArray )
4397 {
4398   typedef ::BLSURFPlugin_Hypothesis BH;
4399   BH* impl = static_cast<BH*>( myBaseImpl );
4400
4401   size_t iEnt = 0;
4402   {
4403     BH::TSizeMap& sizeMapNew = const_cast< BH::TSizeMap& >( impl->_GetSizeMapEntries() );
4404     BH::TSizeMap sizeMap;
4405     sizeMap.swap( sizeMapNew );
4406     BH::TSizeMap::const_iterator entry2size = sizeMap.cbegin();
4407     for ( ; entry2size != sizeMap.cend(); ++entry2size, ++iEnt )
4408       if ( entryArray[ iEnt ].empty() == entry2size->first.empty() )
4409         sizeMapNew[ entryArray[ iEnt ]] =  entry2size->second;
4410   }
4411   {
4412     BH::TSizeMap& sizeMapNew = const_cast< BH::TSizeMap& >( impl->_GetAttractorEntries() );
4413     BH::TSizeMap sizeMap;
4414     sizeMap.swap( sizeMapNew );
4415     BH::TSizeMap::const_iterator entry2size = sizeMap.cbegin();
4416     for ( ; entry2size != sizeMap.cend(); ++entry2size, ++iEnt )
4417       if ( entryArray[ iEnt ].empty() == entry2size->first.empty() )
4418         sizeMapNew[ entryArray[ iEnt ]] =  entry2size->second;
4419   }
4420   {
4421     BH::TAttractorMap& attrMapNew =
4422       const_cast< BH::TAttractorMap& > ( impl->_GetClassAttractorEntries() );
4423     BH::TAttractorMap attrMap;
4424     attrMap.swap( attrMapNew );
4425     BH::TAttractorMap::const_iterator entry2size = attrMap.cbegin();
4426     for ( ; entry2size != attrMap.cend(); ++entry2size, ++iEnt )
4427       if ( entryArray[ iEnt ].empty() == entry2size->first.empty() )
4428         attrMapNew.insert( std::make_pair( entryArray[ iEnt ], entry2size->second ));
4429       else
4430         delete entry2size->second;
4431   }
4432   {
4433     BH::TFaceEntryEnfVertexListMap& faceEntryEnfVertexListMapNew =
4434       const_cast< BH::TFaceEntryEnfVertexListMap& >( impl->_GetAllEnforcedVerticesByFace() );
4435     BH::TFaceEntryEnfVertexListMap faceEntryEnfVertexListMap;
4436     faceEntryEnfVertexListMap.swap( faceEntryEnfVertexListMapNew );
4437
4438     BH::TEnfVertexList& enfVertexList =
4439       const_cast< BH::TEnfVertexList& > ( impl->_GetAllEnforcedVertices() );
4440     enfVertexList.clear(); // avoid removal
4441
4442     impl->ClearAllEnforcedVertices();
4443
4444     BH::TFaceEntryEnfVertexListMap::iterator entry2evList = faceEntryEnfVertexListMap.begin();
4445     for ( ; entry2evList != faceEntryEnfVertexListMap.end(); ++entry2evList )
4446     {
4447       const BH::TEntry& entry = entryArray[ iEnt++ ];
4448       bool faceOk = ( entry.empty() == entry2evList->first.empty() );
4449
4450       BH::TEnfVertexList& evList = entry2evList->second;
4451       BH::TEnfVertexList::iterator evIt = evList.begin();
4452       for ( ; evIt != evList.end(); ++evIt )
4453       {
4454         BH::TEnfVertex* ev = *evIt;
4455         bool ok = faceOk && ( ev->geomEntry.empty() != entryArray[ iEnt ].empty() );
4456         ev->geomEntry = entryArray[ iEnt++ ];
4457         BH::TEntryList faceEntriesNew;
4458         BH::TEntryList::iterator fEnt = ev->faceEntries.begin();
4459         for ( ; fEnt != ev->faceEntries.end(); ++fEnt, ++iEnt )
4460         {
4461           if ( !entryArray[ iEnt ].empty() )
4462             faceEntriesNew.insert( entryArray[ iEnt ]);
4463         }
4464         if ( ok )
4465         {
4466           ev->faceEntries.swap( faceEntriesNew );
4467           impl->AddEnforcedVertex( entry, ev );
4468         }
4469         else
4470         {
4471           delete ev;
4472         }
4473       }
4474     }
4475   }
4476   {
4477     BH::TPreCadPeriodicityVector& preCadPeriodicityVector =
4478       const_cast< BH::TPreCadPeriodicityVector&> ( impl->_GetPreCadFacesPeriodicityVector() );
4479     BH::TPreCadPeriodicityVector::iterator pcp = preCadPeriodicityVector.begin();
4480     for ( ; pcp != preCadPeriodicityVector.end(); ++pcp )
4481     {
4482       pcp->shape1Entry = entryArray[ iEnt++ ];
4483       pcp->shape2Entry = entryArray[ iEnt++ ];
4484       for ( size_t i = 0; i < pcp->theSourceVerticesEntries.size(); ++i, iEnt++ )
4485         pcp->theSourceVerticesEntries[i] = entryArray[ iEnt ];
4486
4487       for ( size_t i = 0; i < pcp->theTargetVerticesEntries.size(); ++i, iEnt++ )
4488         pcp->theTargetVerticesEntries[i] = entryArray[ iEnt ];
4489     }
4490   }
4491   {
4492     BH::TPreCadPeriodicityVector& preCadPeriodicityVector =
4493       const_cast< BH::TPreCadPeriodicityVector&> ( impl->_GetPreCadEdgesPeriodicityVector() );
4494     BH::TPreCadPeriodicityVector::iterator pcp = preCadPeriodicityVector.begin();
4495     for ( ; pcp != preCadPeriodicityVector.end(); ++pcp )
4496     {
4497       pcp->shape1Entry = entryArray[ iEnt++ ];
4498       pcp->shape2Entry = entryArray[ iEnt++ ];
4499       for ( size_t i = 0; i < pcp->theSourceVerticesEntries.size(); ++i, iEnt++ )
4500         pcp->theSourceVerticesEntries[i] = entryArray[ iEnt ];
4501
4502       for ( size_t i = 0; i < pcp->theTargetVerticesEntries.size(); ++i, iEnt++ )
4503         pcp->theTargetVerticesEntries[i] = entryArray[ iEnt ];
4504     }
4505   }
4506
4507   size_t iID = 0;
4508   {
4509     BH::THyperPatchList& hyperPatchListNew =
4510       const_cast< BH::THyperPatchList& >( impl->GetHyperPatches() );
4511     BH::THyperPatchList hyperPatchList;
4512     hyperPatchList.swap( hyperPatchListNew );
4513     BH::THyperPatchList::iterator idSet = hyperPatchList.begin();
4514     for ( ; idSet != hyperPatchList.end(); ++idSet )
4515     {
4516       BH::THyperPatchTags& ids = *idSet;
4517       BH::THyperPatchTags idsNew;
4518       BH::THyperPatchTags::iterator i = ids.begin();
4519       for ( ; i != ids.end(); ++i, ++iID )
4520         if ( subIDArray[ iID ] > 0 )
4521           idsNew.insert( subIDArray[ iID ]);
4522       if ( !idsNew.empty() )
4523         hyperPatchListNew.push_back( idsNew );
4524     }
4525   }
4526
4527   return ( iEnt == entryArray.size() && iID == subIDArray.size() );
4528 }