]> SALOME platform Git repositories - modules/geom.git/blob - src/GEOMImpl/GEOMImpl_IHealingOperations.cxx
Salome HOME
GDD: Check that the PipeTShape is a block if it is required by user
[modules/geom.git] / src / GEOMImpl / GEOMImpl_IHealingOperations.cxx
1 //  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 //  This library is free software; you can redistribute it and/or
7 //  modify it under the terms of the GNU Lesser General Public
8 //  License as published by the Free Software Foundation; either
9 //  version 2.1 of the License.
10 //
11 //  This library is distributed in the hope that it will be useful,
12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 //  Lesser General Public License for more details.
15 //
16 //  You should have received a copy of the GNU Lesser General Public
17 //  License along with this library; if not, write to the Free Software
18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21
22 #ifdef WNT
23 #pragma warning( disable:4786 )
24 #endif
25
26 #include <Standard_Version.hxx>
27 #include <Standard_Stream.hxx>
28
29 #include <GEOMImpl_IHealingOperations.hxx>
30
31 #include <GEOM_PythonDump.hxx>
32
33 #include <GEOMImpl_HealingDriver.hxx>
34 #include <GEOMImpl_Types.hxx>
35 #include <GEOMImpl_IHealing.hxx>
36 #include <GEOMImpl_CopyDriver.hxx>
37
38 #include <ShHealOper_ShapeProcess.hxx>
39
40 #include "utilities.h"
41 #include <OpUtil.hxx>
42 #include <Utils_ExceptHandlers.hxx>
43
44 #include <ShapeAnalysis_FreeBounds.hxx>
45
46 #include <TopoDS_Compound.hxx>
47 #include <TopExp_Explorer.hxx>
48
49 #include <TColStd_HArray1OfExtendedString.hxx>
50 #include <TColStd_HSequenceOfTransient.hxx>
51 #include <TCollection_AsciiString.hxx>
52
53 #include <TDF_Tool.hxx>
54
55 #include <Standard_Failure.hxx>
56 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
57
58 #ifdef OCC_VERSION_SERVICEPACK
59 #define OCC_VERSION_LARGE (OCC_VERSION_MAJOR << 24 | OCC_VERSION_MINOR << 16 | OCC_VERSION_MAINTENANCE << 8 | OCC_VERSION_SERVICEPACK)
60 #else
61 #define OCC_VERSION_LARGE (OCC_VERSION_MAJOR << 24 | OCC_VERSION_MINOR << 16 | OCC_VERSION_MAINTENANCE << 8)
62 #endif
63
64
65 //=============================================================================
66 /*!
67  *   constructor:
68  */
69 //=============================================================================
70
71 GEOMImpl_IHealingOperations::GEOMImpl_IHealingOperations (GEOM_Engine* theEngine, int theDocID)
72 : GEOM_IOperations(theEngine, theDocID)
73 {
74   MESSAGE("GEOMImpl_IHealingOperations::GEOMImpl_IHealingOperations");
75 }
76
77 //=============================================================================
78 /*!
79  *  destructor
80  */
81 //=============================================================================
82
83 GEOMImpl_IHealingOperations::~GEOMImpl_IHealingOperations()
84 {
85   MESSAGE("GEOMImpl_IHealingOperations::~GEOMImpl_IHealingOperations");
86 }
87
88
89 //=============================================================================
90 /*!
91  *  ShapeProcess
92  */
93 //=============================================================================
94 Handle(GEOM_Object) GEOMImpl_IHealingOperations::ShapeProcess (Handle(GEOM_Object) theObject,
95                                   const Handle(TColStd_HArray1OfExtendedString)& theOperators,
96                                   const Handle(TColStd_HArray1OfExtendedString)& theParams,
97                                   const Handle(TColStd_HArray1OfExtendedString)& theValues)
98 {
99   // set error code, check parameters
100   SetErrorCode(KO);
101
102   if (theObject.IsNull())
103     return NULL;
104
105   if (theOperators.IsNull() || theOperators->Length() <= 0) {
106     SetErrorCode("No operators requested");
107     return NULL;
108   }
109
110   Standard_Integer nbParams = 0, nbValues = 0;
111   if (!theParams.IsNull()) {
112     nbParams = theParams->Length();
113   }
114   if (!theValues.IsNull()) {
115     nbValues = theValues->Length();
116   }
117
118   if (nbParams != nbValues) {
119     SetErrorCode("Number of parameter values must be equal to the number of parameters");
120     return NULL;
121   }
122
123   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
124   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
125
126   // Add a new object
127   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
128
129   //Add the function
130   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), SHAPE_PROCESS);
131
132   if (aFunction.IsNull()) return NULL;
133
134   //Check if the function is set correctly
135   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
136
137   // prepare "data container" class IHealing
138   GEOMImpl_IHealing HI(aFunction);
139   HI.SetOriginal(aLastFunction);
140   HI.SetOperators( theOperators );
141   if (nbParams > 0) {
142     HI.SetParameters( theParams );
143     HI.SetValues( theValues );
144   }
145
146   //Compute the translation
147   try {
148 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
149     OCC_CATCH_SIGNALS;
150 #endif
151     if (!GetSolver()->ComputeFunction(aFunction))
152     {
153       SetErrorCode("Shape Healing algorithm failed");
154       return NULL;
155     }
156   }
157   catch (Standard_Failure)
158   {
159     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
160     SetErrorCode(aFail->GetMessageString());
161     return NULL;
162   }
163
164   //Make a Python command
165   GEOM::TPythonDump pd (aFunction);
166   pd << aNewObject << " = geompy.ProcessShape(" << theObject << ", [";
167
168   // list of operators
169   int i = theOperators->Lower(), nb = theOperators->Upper();
170   for ( ; i <= nb; i++) {
171     pd << "\"" << TCollection_AsciiString(theOperators->Value( i )).ToCString()
172       << (( i < nb ) ? "\", " : "\"");
173   }
174   pd << "], [";
175   // list of parameters
176   i = theParams->Lower(); nb = theParams->Upper();
177   for ( ; i <= nb; i++) {
178     pd << "\"" << TCollection_AsciiString(theParams->Value( i )).ToCString()
179       << (( i < nb ) ? "\", " : "\"");
180   }
181   pd << "], [";
182   // list of values
183   i = theValues->Lower(); nb = theValues->Upper();
184   for ( ; i <= nb; i++) {
185     pd << "\"" << TCollection_AsciiString(theValues->Value( i )).ToCString()
186       << (( i < nb ) ? "\", " : "\"");
187   }
188   pd << "])";
189
190   SetErrorCode(OK);
191   return aNewObject;
192 }
193
194 //=============================================================================
195 /*!
196  *  ShapeProcess
197  */
198 //=============================================================================
199 void GEOMImpl_IHealingOperations::GetShapeProcessParameters (std::list<std::string>& theOperations,
200                                                              std::list<std::string>& theParams,
201                                                              std::list<std::string>& theValues)
202 {
203   ShHealOper_ShapeProcess aHealer;
204   TColStd_SequenceOfAsciiString anOperators;
205   int nbOperatorErrors( 0 );
206   if ( aHealer.GetOperators( anOperators ) )
207   {
208     for ( Standard_Integer i = 1; i <= anOperators.Length(); i++ )
209     {
210       std::string anOperation = anOperators.Value( i ).ToCString();
211       if ( GetOperatorParameters( anOperation, theParams, theValues ) )
212         theOperations.push_back( anOperation );
213       else
214         nbOperatorErrors++;
215     }
216   }
217   else
218   {
219     SetErrorCode("ERROR retrieving operators (GEOMImpl_IHealingOperations)");
220   }
221
222   if ( nbOperatorErrors ) {
223     TCollection_AsciiString aMsg ("ERRORS retrieving ShapeProcess parameters (GEOMImpl_IHealingOperations): nbOperatorErrors = ");
224     aMsg += TCollection_AsciiString( nbOperatorErrors );
225     MESSAGE(aMsg.ToCString());
226   }
227 }
228
229 //=============================================================================
230 /*!
231  *  GetOperatorParameters
232  */
233 //=============================================================================
234 bool GEOMImpl_IHealingOperations::GetOperatorParameters( const std::string theOperation,
235                                                          std::list<std::string>& theParams,
236                                                          std::list<std::string>& theValues )
237 {
238   ShHealOper_ShapeProcess aHealer;
239   int nbParamValueErrors( 0 );
240   std::list<std::string> aParams;
241   if ( GetParameters( theOperation, aParams ) ) {
242     for ( std::list<std::string>::iterator it = aParams.begin(); it != aParams.end(); ++it ) {
243       TCollection_AsciiString aParam( (Standard_CString)(*it).c_str() );
244       TCollection_AsciiString aValue;
245       if ( aHealer.GetParameter( aParam, aValue ) ) {
246         theParams.push_back( aParam.ToCString() );
247         theValues.push_back( aValue.ToCString() );
248       }
249       else
250         nbParamValueErrors++;
251     }
252   }
253   else
254     return false;
255
256   if ( nbParamValueErrors ) {
257     TCollection_AsciiString aMsg ("ERRORS retrieving ShapeProcess parameter values (GEOMImpl_IHealingOperations): nbParamValueErrors = ");
258     aMsg += TCollection_AsciiString( nbParamValueErrors );
259     MESSAGE(aMsg.ToCString());
260   }
261
262   return true;
263 }
264
265 //=============================================================================
266 /*!
267  *  GetParameters
268  */
269 //=============================================================================
270 bool GEOMImpl_IHealingOperations::GetParameters (const std::string theOperation,
271                                                  std::list<std::string>& theParams)
272 {
273   if ( theOperation == "SplitAngle" ) {
274     theParams.push_back( "SplitAngle.Angle" );
275     theParams.push_back( "SplitAngle.MaxTolerance" );
276
277   } else if ( theOperation == "SplitClosedFaces" ) {
278     theParams.push_back( "SplitClosedFaces.NbSplitPoints" );
279
280   } else if ( theOperation == "FixFaceSize" ) {
281     theParams.push_back( "FixFaceSize.Tolerance" );
282
283   } else if( theOperation == "DropSmallEdges" ) {
284     theParams.push_back( "DropSmallEdges.Tolerance3d" );
285
286   } else if( theOperation == "BSplineRestriction" ) {
287     theParams.push_back( "BSplineRestriction.SurfaceMode" );
288     theParams.push_back( "BSplineRestriction.Curve3dMode" );
289     theParams.push_back( "BSplineRestriction.Curve2dMode" );
290     theParams.push_back( "BSplineRestriction.Tolerance3d" );
291     theParams.push_back( "BSplineRestriction.Tolerance2d" );
292     theParams.push_back( "BSplineRestriction.RequiredDegree" );
293     theParams.push_back( "BSplineRestriction.RequiredNbSegments" );
294     theParams.push_back( "BSplineRestriction.Continuity3d" );
295     theParams.push_back( "BSplineRestriction.Continuity2d" );
296
297   } else if( theOperation == "SplitContinuity" ) {
298     theParams.push_back( "SplitContinuity.Tolerance3d" );
299     theParams.push_back( "SplitContinuity.SurfaceContinuity" );
300     theParams.push_back( "SplitContinuity.CurveContinuity" );
301
302   } else if( theOperation == "ToBezier" ) {
303     theParams.push_back( "ToBezier.SurfaceMode" );
304     theParams.push_back( "ToBezier.Curve3dMode" );
305     theParams.push_back( "ToBezier.Curve2dMode" );
306     theParams.push_back( "ToBezier.MaxTolerance" );
307
308   } else if( theOperation == "SameParameter" ) {
309     theParams.push_back( "SameParameter.Tolerance3d" );
310
311   } else if( theOperation == "FixShape" ) {
312     theParams.push_back( "FixShape.Tolerance3d" );
313     theParams.push_back( "FixShape.MaxTolerance3d" );
314
315   } else {
316     return false;
317   }
318
319   return true;
320 }
321
322 //=============================================================================
323 /*!
324  *  SuppressFaces
325  */
326 //=============================================================================
327 Handle(GEOM_Object) GEOMImpl_IHealingOperations::SuppressFaces
328        (Handle(GEOM_Object) theObject, const Handle(TColStd_HArray1OfInteger)& theFaces)
329 {
330   // set error code, check parameters
331   SetErrorCode(KO);
332
333   if (theObject.IsNull()) // if theFaces.IsNull() - it's OK, it means that ALL faces must be removed..
334     return NULL;
335
336   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
337   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
338
339   // Add a new object
340   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
341
342   //Add the function
343   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), SUPPRESS_FACES);
344
345   if (aFunction.IsNull()) return NULL;
346
347   //Check if the function is set correctly
348   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
349
350   // prepare "data container" class IHealing
351   GEOMImpl_IHealing HI (aFunction);
352   HI.SetFaces(theFaces);
353   HI.SetOriginal(aLastFunction);
354
355   //Compute the translation
356   try {
357 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
358     OCC_CATCH_SIGNALS;
359 #endif
360     if (!GetSolver()->ComputeFunction(aFunction))
361     {
362       SetErrorCode("Healing driver failed");
363       return NULL;
364     }
365   }
366   catch (Standard_Failure)
367   {
368     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
369     SetErrorCode(aFail->GetMessageString());
370     return NULL;
371   }
372
373   //Make a Python command
374   GEOM::TPythonDump pd (aFunction);
375   pd << aNewObject << " = geompy.SuppressFaces(" << theObject << ", [";
376
377   // list of face ids
378   int i = theFaces->Lower(), nb = theFaces->Upper();
379   for ( ; i <= nb; i++)
380     pd << theFaces->Value( i ) << (( i < nb ) ? ", " : "])");
381
382   SetErrorCode(OK);
383   return aNewObject;
384 }
385
386 //=============================================================================
387 /*!
388  *  CloseContour
389  */
390 //=============================================================================
391 Handle(GEOM_Object) GEOMImpl_IHealingOperations::CloseContour
392                     (Handle(GEOM_Object) theObject,
393                      const Handle(TColStd_HArray1OfInteger)& theWires,
394                      bool isCommonVertex)
395 {
396   // set error code, check parameters
397   SetErrorCode(KO);
398
399   if (theObject.IsNull())
400   {
401     SetErrorCode("NULL object given");
402     return NULL;
403   }
404
405   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
406   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
407
408   // Add a new object
409   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
410
411   //Add the function
412   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), CLOSE_CONTOUR);
413
414   if (aFunction.IsNull()) return NULL;
415
416   //Check if the function is set correctly
417   if(aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
418
419   // prepare "data container" class IHealing
420   GEOMImpl_IHealing HI(aFunction);
421   HI.SetWires( theWires );
422   HI.SetIsCommonVertex( isCommonVertex );
423   HI.SetOriginal( aLastFunction );
424
425   //Compute the translation
426   try {
427 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
428     OCC_CATCH_SIGNALS;
429 #endif
430     if (!GetSolver()->ComputeFunction(aFunction))
431     {
432       SetErrorCode("Healing driver failed");
433       return NULL;
434     }
435   }
436   catch (Standard_Failure)
437   {
438         Handle(Standard_Failure) aFail = Standard_Failure::Caught();
439     SetErrorCode(aFail->GetMessageString());
440     return NULL;
441   }
442
443   //Make a Python command
444   GEOM::TPythonDump pd (aFunction);
445   pd << aNewObject << " = geompy.CloseContour(" << theObject << ", [";
446
447   // list of wire ids
448   if (!theWires.IsNull())
449   {
450     int i = theWires->Lower(), nb = theWires->Upper();
451     pd << theWires->Value(i++);
452     while (i <= nb)
453       pd << ", " << theWires->Value(i++);
454   }
455   pd << "], " << (int)isCommonVertex << ")";
456
457   SetErrorCode(OK);
458   return aNewObject;
459 }
460
461 //=============================================================================
462 /*!
463  *  RemoveIntWires
464  */
465 //=============================================================================
466 Handle(GEOM_Object) GEOMImpl_IHealingOperations::RemoveIntWires
467        (Handle(GEOM_Object) theObject, const Handle(TColStd_HArray1OfInteger)& theWires)
468 {
469   // set error code, check parameters
470   SetErrorCode(KO);
471
472   if (theObject.IsNull()) // if theWires is NULL it's OK, it means that ALL wires must be removed
473     return NULL;
474
475   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
476   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
477
478   // Add a new object
479   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
480
481   //Add the function
482   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), REMOVE_INT_WIRES);
483
484   if (aFunction.IsNull()) return NULL;
485
486   //Check if the function is set correctly
487   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
488
489   // prepare "data container" class IHealing
490   GEOMImpl_IHealing HI(aFunction);
491   HI.SetWires( theWires );
492   HI.SetOriginal( aLastFunction );
493
494   //Compute the translation
495   try {
496 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
497     OCC_CATCH_SIGNALS;
498 #endif
499     if (!GetSolver()->ComputeFunction(aFunction))
500     {
501       SetErrorCode("Healing driver failed");
502       return NULL;
503     }
504   }
505   catch (Standard_Failure)
506   {
507     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
508     SetErrorCode(aFail->GetMessageString());
509     return NULL;
510   }
511
512   //Make a Python command
513   GEOM::TPythonDump pd (aFunction);
514   pd << aNewObject << " = geompy.SuppressInternalWires(" << theObject << ", [";
515
516   // list of wire ids
517   if (!theWires.IsNull()) {
518     int i = theWires->Lower(), nb = theWires->Upper();
519     for ( ; i <= nb; i++)
520       pd << theWires->Value( i ) << (( i < nb ) ? ", " : "])");
521   } else {
522     pd << "])";
523   }
524
525   SetErrorCode(OK);
526   return aNewObject;
527 }
528
529 //=============================================================================
530 /*!
531  *  FillHoles
532  */
533 //=============================================================================
534 Handle(GEOM_Object) GEOMImpl_IHealingOperations::FillHoles (Handle(GEOM_Object) theObject,
535                                                             const Handle(TColStd_HArray1OfInteger)& theWires)
536 {
537   // set error code, check parameters
538   SetErrorCode(KO);
539
540   if (theObject.IsNull()) // if theWires is NULL it's OK, it means that ALL holes must be removed
541     return NULL;
542
543   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
544   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
545
546   // Add a new object
547   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
548
549   //Add the function
550   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), FILL_HOLES);
551
552   if (aFunction.IsNull()) return NULL;
553
554   //Check if the function is set correctly
555   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
556
557   // prepare "data container" class IHealing
558   GEOMImpl_IHealing HI(aFunction);
559   HI.SetWires( theWires );
560   HI.SetOriginal( aLastFunction );
561
562   //Compute the translation
563   try {
564 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
565     OCC_CATCH_SIGNALS;
566 #endif
567     if (!GetSolver()->ComputeFunction(aFunction))
568     {
569       SetErrorCode("Healing driver failed");
570       return NULL;
571     }
572   }
573   catch (Standard_Failure)
574   {
575         Handle(Standard_Failure) aFail = Standard_Failure::Caught();
576     SetErrorCode(aFail->GetMessageString());
577     return NULL;
578   }
579
580   //Make a Python command
581   GEOM::TPythonDump pd (aFunction);
582   pd << aNewObject << " = geompy.SuppressHoles(" << theObject << ", [";
583
584   // list of wire ids
585   if ( theWires.IsNull() )
586     pd << "])";
587   else {
588     int i = theWires->Lower(), nb = theWires->Upper();
589     for ( ; i <= nb; i++)
590       pd << theWires->Value( i ) << (( i < nb ) ? ", " : "])");
591   }
592
593   SetErrorCode(OK);
594   return aNewObject;
595 }
596
597 //=============================================================================
598 /*!
599  *  Sew
600  */
601 //=============================================================================
602 Handle(GEOM_Object) GEOMImpl_IHealingOperations::Sew (Handle(GEOM_Object) theObject,
603                                                       double theTolerance)
604 {
605   // set error code, check parameters
606   SetErrorCode(KO);
607
608   if (theObject.IsNull())
609     return NULL;
610
611   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
612   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
613
614   // Add a new object
615   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
616
617   //Add the function
618   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), SEWING);
619
620   if (aFunction.IsNull()) return NULL;
621
622   //Check if the function is set correctly
623   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
624
625   // prepare "data container" class IHealing
626   GEOMImpl_IHealing HI(aFunction);
627   HI.SetTolerance( theTolerance );
628   HI.SetOriginal( aLastFunction );
629
630   //Compute the translation
631   try {
632 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
633     OCC_CATCH_SIGNALS;
634 #endif
635     if (!GetSolver()->ComputeFunction(aFunction))
636     {
637       SetErrorCode("Healing driver failed");
638       return NULL;
639     }
640   }
641   catch (Standard_Failure)
642   {
643         Handle(Standard_Failure) aFail = Standard_Failure::Caught();
644     SetErrorCode(aFail->GetMessageString());
645     return NULL;
646   }
647
648   //Make a Python command
649   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.Sew("
650                                << theObject << ", " << theTolerance << ")";
651
652   SetErrorCode(OK);
653   return aNewObject;
654 }
655
656 //=============================================================================
657 /*!
658  *  DivideEdge
659  */
660 //=============================================================================
661 Handle(GEOM_Object) GEOMImpl_IHealingOperations::DivideEdge (Handle(GEOM_Object) theObject,
662                                                              int theIndex,
663                                                              double theValue,
664                                                              bool isByParameter)
665 {
666   // set error code, check parameters
667   SetErrorCode(KO);
668
669   if (theObject.IsNull())
670     return NULL;
671
672   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
673   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
674
675   // Add a new object
676   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
677
678   //Add the function
679   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), DIVIDE_EDGE);
680
681   if (aFunction.IsNull()) return NULL;
682
683   //Check if the function is set correctly
684   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
685
686   // prepare "data container" class IHealing
687   GEOMImpl_IHealing HI(aFunction);
688   HI.SetIndex( theIndex );
689   HI.SetDevideEdgeValue( theValue );
690   HI.SetIsByParameter( isByParameter );
691   HI.SetOriginal( aLastFunction );
692
693   //Compute the translation
694   try {
695 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
696     OCC_CATCH_SIGNALS;
697 #endif
698     if (!GetSolver()->ComputeFunction(aFunction))
699     {
700       SetErrorCode("Healing driver failed");
701       return NULL;
702     }
703   }
704   catch (Standard_Failure)
705   {
706         Handle(Standard_Failure) aFail = Standard_Failure::Caught();
707     SetErrorCode(aFail->GetMessageString());
708     return NULL;
709   }
710
711   //Make a Python command
712   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.DivideEdge(" << theObject
713     << ", " << theIndex << ", " << theValue << ", " << (int)isByParameter << ")";
714
715   SetErrorCode(OK);
716   return aNewObject;
717 }
718
719 //=============================================================================
720 /*!
721  *  GetFreeBoundary
722  */
723 //=============================================================================
724 bool GEOMImpl_IHealingOperations::GetFreeBoundary (Handle(GEOM_Object) theObject,
725                                                    Handle(TColStd_HSequenceOfTransient)& theClosed,
726                                                    Handle(TColStd_HSequenceOfTransient)& theOpen )
727 {
728   // set error code, check parameters
729   SetErrorCode(KO);
730
731   if ( theObject.IsNull() || theClosed.IsNull() || theOpen.IsNull() )
732     return false;
733
734   TopoDS_Shape aShape = theObject->GetValue();
735   if ( aShape.IsNull() )
736     return false;
737
738   // get free boundary shapes
739
740 #if OCC_VERSION_LARGE > 0x06030008
741   ShapeAnalysis_FreeBounds anAnalizer(aShape, Standard_False,
742                                       Standard_True, Standard_True);
743 #else
744   ShapeAnalysis_FreeBounds anAnalizer(aShape);
745 #endif
746   TopoDS_Compound aClosed = anAnalizer.GetClosedWires();
747   TopoDS_Compound anOpen = anAnalizer.GetOpenWires();
748
749   // iterate through shapes and append them to the return sequence
750   Handle(GEOM_Object) anObj;
751   Handle(GEOM_Function) aFunction;
752   TopExp_Explorer anExp;
753   for ( anExp.Init( aClosed, TopAbs_WIRE ); anExp.More(); anExp.Next() )
754   {
755     anObj = GetEngine()->AddObject( GetDocID(), GEOM_FREE_BOUNDS );
756     aFunction = anObj->AddFunction( GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF );
757     TopoDS_Shape aValueShape = anExp.Current();
758     aFunction->SetValue( aValueShape );
759     theClosed->Append(anObj);
760   }
761   for ( anExp.Init( anOpen, TopAbs_WIRE ); anExp.More(); anExp.Next() )
762   {
763     anObj = GetEngine()->AddObject( GetDocID(), GEOM_FREE_BOUNDS );
764     aFunction = anObj->AddFunction( GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF );
765     TopoDS_Shape aValueShape = anExp.Current();
766     aFunction->SetValue( aValueShape );
767     theOpen->Append(anObj);
768   }
769
770   if(!aFunction.IsNull()) {
771
772     //Make a Python command
773     GEOM::TPythonDump pd (aFunction);
774
775     Standard_Integer i, aLen = theClosed->Length();
776     if (aLen > 0) {
777       pd << "(isDone, [";
778       for (i = 1; i <= aLen; i++) {
779         Handle(GEOM_Object) anObj_i = Handle(GEOM_Object)::DownCast(theClosed->Value(i));
780         pd << anObj_i << ((i < aLen) ? ", " : "");
781       }
782       pd << "], ";
783     } else {
784       pd << "(isDone, empty_list, ";
785     }
786
787     aLen = theOpen->Length();
788     if (aLen > 0) {
789       pd << "[";
790       for (i = 1; i <= aLen; i++) {
791         Handle(GEOM_Object) anObj_i = Handle(GEOM_Object)::DownCast(theOpen->Value(i));
792         pd << anObj_i << ((i < aLen) ? ", " : "");
793       }
794       pd << "]";
795     } else {
796       pd << "empty_list";
797     }
798
799     pd << ") = geompy.GetFreeBoundary(" << theObject << ")";
800   }
801
802   SetErrorCode(OK);
803   return true;
804 }
805
806
807 //=============================================================================
808 /*!
809  *  ChangeOrientation
810  */
811 //=============================================================================
812 Handle(GEOM_Object) GEOMImpl_IHealingOperations::ChangeOrientation (Handle(GEOM_Object) theObject)
813 {
814   // set error code, check parameters
815   SetErrorCode(KO);
816
817   if (theObject.IsNull())
818     return NULL;
819
820   if (!theObject->IsMainShape()) {
821     SetErrorCode("Sub shape cannot be transformed - need to create a copy");
822     return NULL;
823   }
824
825   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
826   if (aLastFunction.IsNull())
827     return NULL; //There is no function which creates an object to be processed
828
829   //Add the function
830   aFunction = theObject->AddFunction(GEOMImpl_HealingDriver::GetID(), CHANGE_ORIENTATION);
831
832   if (aFunction.IsNull())
833     return NULL;
834
835   //Check if the function is set correctly
836   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
837
838   // prepare "data container" class IHealing
839   GEOMImpl_IHealing HI(aFunction);
840   HI.SetOriginal( aLastFunction );
841
842   //Compute the translation
843   try {
844 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
845     OCC_CATCH_SIGNALS;
846 #endif
847     if (!GetSolver()->ComputeFunction(aFunction)) {
848       SetErrorCode("Healing driver failed");
849       return NULL;
850     }
851   }
852   catch (Standard_Failure) {
853     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
854     SetErrorCode(aFail->GetMessageString());
855     return NULL;
856   }
857
858   //Make a Python command
859   GEOM::TPythonDump(aFunction) << "geompy.ChangeOrientationShell("
860                                << theObject << ")";
861
862   SetErrorCode(OK);
863   return theObject;
864 }
865
866 //=============================================================================
867 /*!
868  *  ChangeOrientationCopy
869  */
870 //=============================================================================
871 Handle(GEOM_Object) GEOMImpl_IHealingOperations::ChangeOrientationCopy (Handle(GEOM_Object) theObject)
872 {
873   // set error code, check parameters
874   SetErrorCode(KO);
875
876   if (theObject.IsNull())
877     return NULL;
878
879   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
880   if (aLastFunction.IsNull())
881     return NULL; //There is no function which creates an object to be processed
882
883   // Add a new object
884   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), theObject->GetType() );
885
886   //Add the function
887   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), CHANGE_ORIENTATION);
888
889   if (aFunction.IsNull())
890     return NULL;
891
892   //Check if the function is set correctly
893   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
894
895   // prepare "data container" class IHealing
896   GEOMImpl_IHealing HI(aFunction);
897   HI.SetOriginal( aLastFunction );
898
899   //Compute the translation
900   try {
901 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
902     OCC_CATCH_SIGNALS;
903 #endif
904     if (!GetSolver()->ComputeFunction(aFunction)) {
905       SetErrorCode("Healing driver failed");
906       return NULL;
907     }
908   }
909   catch (Standard_Failure) {
910     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
911     SetErrorCode(aFail->GetMessageString());
912     return NULL;
913   }
914
915   //Make a Python command
916   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.ChangeOrientationShellCopy("
917                                << theObject << ")";
918
919   SetErrorCode(OK);
920   return aNewObject;
921 }
922
923 //=============================================================================
924 /*!
925  *  LimitTolerance
926  */
927 //=============================================================================
928 Handle(GEOM_Object) GEOMImpl_IHealingOperations::LimitTolerance (Handle(GEOM_Object) theObject,
929                                                                  double theTolerance)
930 {
931   // Set error code, check parameters
932   SetErrorCode(KO);
933
934   if (theObject.IsNull())
935     return NULL;
936
937   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
938   if (aLastFunction.IsNull())
939     return NULL; // There is no function which creates an object to be processed
940
941   // Add a new object
942   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject(GetDocID(), theObject->GetType());
943
944   // Add the function
945   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), LIMIT_TOLERANCE);
946
947   if (aFunction.IsNull())
948     return NULL;
949
950   // Check if the function is set correctly
951   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
952
953   // Prepare "data container" class IHealing
954   GEOMImpl_IHealing HI (aFunction);
955   HI.SetOriginal(aLastFunction);
956   HI.SetTolerance(theTolerance);
957
958   // Compute
959   try {
960 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
961     OCC_CATCH_SIGNALS;
962 #endif
963     if (!GetSolver()->ComputeFunction(aFunction)) {
964       SetErrorCode("Healing driver failed");
965       return NULL;
966     }
967   }
968   catch (Standard_Failure) {
969     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
970     SetErrorCode(aFail->GetMessageString());
971     return NULL;
972   }
973
974   // Make a Python command
975   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.LimitTolerance("
976                                << theObject << ", " << theTolerance << ")";
977
978   SetErrorCode(OK);
979   return aNewObject;
980 }