]> SALOME platform Git repositories - modules/geom.git/blob - src/GEOM_I/GEOM_IHealingOperations_i.cc
Salome HOME
0022743: EDF GEOM: Regression in MakePipeTShapeChamfer: Some faces are missing in...
[modules/geom.git] / src / GEOM_I / GEOM_IHealingOperations_i.cc
1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 #include <Standard_Stream.hxx>
24
25 #include <list>
26
27 #include "GEOM_IHealingOperations_i.hh"
28 #include "GEOM_Engine.hxx"
29 #include "GEOM_Object.hxx"
30
31 #include "utilities.h"
32 #include "OpUtil.hxx"
33 #include "Utils_ExceptHandlers.hxx"
34 #include <Basics_Utils.hxx>
35
36 #include <TColStd_HSequenceOfTransient.hxx>
37
38 //=============================================================================
39 /*!
40  *   constructor:
41  */
42 //=============================================================================
43
44 GEOM_IHealingOperations_i::GEOM_IHealingOperations_i (PortableServer::POA_ptr thePOA,
45                                                       GEOM::GEOM_Gen_ptr theEngine,
46                                                       ::GEOMImpl_IHealingOperations* theImpl)
47 :GEOM_IOperations_i(thePOA, theEngine, theImpl)
48 {
49   MESSAGE("GEOM_IHealingOperations_i::GEOM_IHealingOperations_i");
50 }
51
52 //=============================================================================
53 /*!
54  *  destructor
55  */
56 //=============================================================================
57
58 GEOM_IHealingOperations_i::~GEOM_IHealingOperations_i()
59 {
60   MESSAGE("GEOM_IHealingOperations_i::~GEOM_IHealingOperations_i");
61 }
62
63 //=============================================================================
64 /*!
65  *  Convert
66  */
67 //=============================================================================
68 Handle(TColStd_HArray1OfInteger) GEOM_IHealingOperations_i::Convert
69                                           (const GEOM::short_array& theInArray)
70 {
71   Handle(TColStd_HArray1OfInteger) anOutArray;
72   int n = theInArray.length();
73   if ( n <= 0 )
74     return anOutArray;
75   anOutArray = new TColStd_HArray1OfInteger( 1, n );
76   for (int i = 0; i < n; i++)
77     anOutArray->SetValue( i+1, theInArray[i] );
78   return anOutArray;
79 }
80
81 //=============================================================================
82 /*!
83  *  ProcessShape
84  */
85 //=============================================================================
86 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::ProcessShape (GEOM::GEOM_Object_ptr theObject,
87                                                                const GEOM::string_array& theOperations,
88                                                                const GEOM::string_array& theParams,
89                                                                const GEOM::string_array& theValues)
90 {
91   Kernel_Utils::Localizer loc;
92
93   GEOM::GEOM_Object_var aGEOMObject;
94
95   // Set a not done flag
96   GetOperations()->SetNotDone();
97
98   // Check if theOperations has more than 0 elements and theParams and theValues have the same length
99   //if (theOperations.length() <= 0 || theParams.length() != theValues.length())
100   //  return aGEOMObject._retn();
101
102   // Get the object itself
103   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
104   if (anObject.IsNull())
105     return aGEOMObject._retn();
106
107   // Perform
108   Handle(GEOM_Object) aNewObject = GetOperations()->ShapeProcess( anObject,
109     ConvertStringArray( theOperations ), ConvertStringArray( theParams ),
110     ConvertStringArray( theValues ) );
111   if ( !GetOperations()->IsDone() || aNewObject.IsNull() )
112     return aGEOMObject._retn();
113
114   return GetObject( aNewObject );
115 }
116
117 //=============================================================================
118 /*!
119  *  GetShapeProcessParameters
120  */
121 //=============================================================================
122 void GEOM_IHealingOperations_i::GetShapeProcessParameters(GEOM::string_array_out theOperations,
123                                                           GEOM::string_array_out theParams,
124                                                           GEOM::string_array_out theValues)
125 {
126   GEOM::string_array_var anOpArray = new GEOM::string_array();
127   GEOM::string_array_var aParArray = new GEOM::string_array();
128   GEOM::string_array_var aValArray = new GEOM::string_array();
129
130   // retrieve the values as stl-lists
131   std::list<std::string> operationsList, paramsList, valuesList;
132   GetOperations()->GetShapeProcessParameters( operationsList, paramsList, valuesList );
133   const int opSize = operationsList.size(),
134   parSize = paramsList.size(),
135   valSize = valuesList.size();
136
137   if ( opSize >= 0 && parSize >= 0 && parSize == valSize ) {
138     // allocate the CORBA arrays, sizes == returned lists' sizes
139     anOpArray->length(opSize);
140     aParArray->length(parSize);
141     aValArray->length(valSize);
142
143     // fill the local CORBA arrays with values from lists
144     std::list<std::string>::iterator opIt, parIt, valIt;
145     int i = 0;
146     for ( opIt = operationsList.begin(); opIt != operationsList.end(); i++,++opIt )
147       anOpArray[i] = CORBA::string_dup( (*opIt).c_str() );
148
149     for ( i = 0, parIt = paramsList.begin(), valIt = valuesList.begin();
150           parIt != paramsList.end(); i++, ++parIt,++valIt ) {
151       aParArray[i] = CORBA::string_dup( (*parIt).c_str() );
152       aValArray[i] = CORBA::string_dup( (*valIt).c_str() );
153     }
154   }
155
156   // initialize out-parameters with local arrays
157   theOperations = anOpArray._retn();
158   theParams = aParArray._retn();
159   theValues = aValArray._retn();
160 }
161
162 //=============================================================================
163 /*!
164  *  GetOperatorParameters
165  */
166 //=============================================================================
167 void GEOM_IHealingOperations_i::GetOperatorParameters (const char* theOperator,
168                                                        GEOM::string_array_out theParams,
169                                                        GEOM::string_array_out theValues)
170 {
171   GEOM::string_array_var aParArray = new GEOM::string_array();
172   GEOM::string_array_var aValArray = new GEOM::string_array();
173
174   // retrieve the values as stl-lists
175   std::list<std::string> paramsList, valuesList;
176   if ( GetOperations()->GetOperatorParameters( theOperator, paramsList, valuesList ) ) {
177     const int parSize = paramsList.size(), valSize = valuesList.size();
178
179     if ( parSize == valSize ) {
180       aParArray->length(parSize);
181       aValArray->length(valSize);
182
183       // fill the local CORBA arrays with values from lists
184       std::list<std::string>::iterator parIt, valIt;
185       int i;
186       for ( i = 0, parIt = paramsList.begin(), valIt = valuesList.begin();
187             parIt != paramsList.end(); i++, ++parIt,++valIt ) {
188         aParArray[i] = CORBA::string_dup( (*parIt).c_str() );
189         aValArray[i] = CORBA::string_dup( (*valIt).c_str() );
190       }
191     }
192   }
193
194   // initialize out-parameters with local arrays
195   theParams = aParArray._retn();
196   theValues = aValArray._retn();
197 }
198
199 //=============================================================================
200 /*!
201  *  SuppressFaces
202  */
203 //=============================================================================
204 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::SuppressFaces (GEOM::GEOM_Object_ptr theObject,
205                                                                 const GEOM::short_array& theFaces)
206 {
207   GEOM::GEOM_Object_var aGEOMObject;
208
209   // Set a not done flag
210   GetOperations()->SetNotDone();
211
212   // Get the object itself
213   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
214   if (anObject.IsNull())
215     return aGEOMObject._retn();
216
217   // if theFaces is empty - it's OK, it means that ALL faces must be removed
218
219   // Perform
220   Handle(GEOM_Object) aNewObject =
221     GetOperations()->SuppressFaces( anObject, Convert( theFaces ) );
222   if (!GetOperations()->IsDone() || aNewObject.IsNull())
223     return aGEOMObject._retn();
224
225   return  GetObject( aNewObject );
226 }
227
228 //=============================================================================
229 /*!
230  *  CloseContour
231  */
232 //=============================================================================
233 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::CloseContour (GEOM::GEOM_Object_ptr theObject,
234                                                                const GEOM::short_array& theWires,
235                                                                CORBA::Boolean isCommonVertex)
236 {
237   GEOM::GEOM_Object_var aGEOMObject;
238
239   // Set a not done flag
240   GetOperations()->SetNotDone();
241
242   // Get the object itself
243   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
244   if (anObject.IsNull())
245     return aGEOMObject._retn();
246
247   // Perform
248   Handle(GEOM_Object) aNewObject =
249     GetOperations()->CloseContour( anObject, Convert( theWires ), isCommonVertex );
250   if (!GetOperations()->IsDone() || aNewObject.IsNull())
251     return aGEOMObject._retn();
252
253   return GetObject(aNewObject);
254 }
255
256 //=============================================================================
257 /*!
258  *  RemoveIntWires
259  */
260 //=============================================================================
261 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::RemoveIntWires (GEOM::GEOM_Object_ptr theObject,
262                                                                  const GEOM::short_array& theWires)
263 {
264   GEOM::GEOM_Object_var aGEOMObject;
265
266   // Set a not done flag
267   GetOperations()->SetNotDone();
268
269   // Get the object itself
270   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
271   if (anObject.IsNull())
272     return aGEOMObject._retn();
273
274   // if theWires is empty - it's OK, it means that ALL wires should be removed
275
276   // Perform
277   Handle(GEOM_Object) aNewObject =
278     GetOperations()->RemoveIntWires( anObject, Convert( theWires ) );
279   if (!GetOperations()->IsDone() || aNewObject.IsNull())
280     return aGEOMObject._retn();
281
282   return GetObject(aNewObject);
283 }
284
285 //=============================================================================
286 /*!
287  *  FillHoles
288  */
289 //=============================================================================
290 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::FillHoles (GEOM::GEOM_Object_ptr theObject,
291                                                             const GEOM::short_array& theWires)
292 {
293   GEOM::GEOM_Object_var aGEOMObject;
294
295   // Set a not done flag
296   GetOperations()->SetNotDone();
297
298   // Get the object itself
299   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
300   if (anObject.IsNull())
301     return aGEOMObject._retn();
302
303   // if theWires is empty - it's OK, it means that ALL wires should be removed
304
305   // Perform
306   Handle(GEOM_Object) aNewObject =
307     GetOperations()->FillHoles( anObject, Convert( theWires ) );
308   if (!GetOperations()->IsDone() || aNewObject.IsNull())
309     return aGEOMObject._retn();
310
311   return GetObject(aNewObject);
312 }
313
314 //=============================================================================
315 /*!
316  *  Sew
317  */
318 //=============================================================================
319 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::Sew (GEOM::GEOM_Object_ptr theObject,
320                                                       CORBA::Double theTolerance)
321 {
322   GEOM::GEOM_Object_var aGEOMObject;
323
324   // Set a not done flag
325   GetOperations()->SetNotDone();
326
327   // Check parameters
328   if (theTolerance < 0)
329     return aGEOMObject._retn();
330
331   // Get the object itself
332   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
333   if (anObject.IsNull())
334     return aGEOMObject._retn();
335
336   // Perform
337   Handle(GEOM_Object) aNewObject =
338     GetOperations()->Sew( anObject, theTolerance, false );
339   if (!GetOperations()->IsDone() || aNewObject.IsNull())
340     return aGEOMObject._retn();
341
342   return GetObject(aNewObject);
343 }
344
345 //=============================================================================
346 /*!
347  *  SewAllowNonManifold
348  */
349 //=============================================================================
350 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::SewAllowNonManifold (GEOM::GEOM_Object_ptr theObject,
351                                                                       CORBA::Double theTolerance)
352 {
353   GEOM::GEOM_Object_var aGEOMObject;
354
355   // Set a not done flag
356   GetOperations()->SetNotDone();
357
358   // Check parameters
359   if (theTolerance < 0)
360     return aGEOMObject._retn();
361
362   // Get the object itself
363   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
364   if (anObject.IsNull())
365     return aGEOMObject._retn();
366
367   // Perform
368   Handle(GEOM_Object) aNewObject =
369     GetOperations()->Sew( anObject, theTolerance, true );
370   if (!GetOperations()->IsDone() || aNewObject.IsNull())
371     return aGEOMObject._retn();
372
373   return GetObject(aNewObject);
374 }
375
376 //=============================================================================
377 /*!
378  *  RemoveInternalFaces
379  */
380 //=============================================================================
381 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::RemoveInternalFaces (GEOM::GEOM_Object_ptr theCompound)
382 {
383   GEOM::GEOM_Object_var aGEOMObject;
384
385   // Set a not done flag
386   GetOperations()->SetNotDone();
387
388   // Get the object
389   Handle(GEOM_Object) anObject = GetObjectImpl(theCompound);
390   if (anObject.IsNull())
391     return aGEOMObject._retn();
392
393   // Perform
394   Handle(GEOM_Object) aNewObject = GetOperations()->RemoveInternalFaces(anObject);
395   if (!GetOperations()->IsDone() || aNewObject.IsNull())
396     return aGEOMObject._retn();
397
398   return GetObject(aNewObject);
399 }
400
401 //=============================================================================
402 /*!
403  *  DivideEdge
404  */
405 //=============================================================================
406 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::DivideEdge (GEOM::GEOM_Object_ptr theObject,
407                                                              CORBA::Short theIndex,
408                                                              CORBA::Double theValue,
409                                                              CORBA::Boolean isByParameter)
410 {
411   GEOM::GEOM_Object_var aGEOMObject;
412
413   // Set a not done flag
414   GetOperations()->SetNotDone();
415
416   // Check parameters
417   if (theValue < 0 || theValue > 1)
418     return aGEOMObject._retn();
419
420   // Get the object itself
421   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
422   if (anObject.IsNull())
423     return aGEOMObject._retn();
424
425   // Perform
426   Handle(GEOM_Object) aNewObject =
427     GetOperations()->DivideEdge( anObject, theIndex, theValue, isByParameter );
428   if (!GetOperations()->IsDone() || aNewObject.IsNull())
429     return aGEOMObject._retn();
430
431   return GetObject(aNewObject);
432 }
433
434 //=============================================================================
435 /*!
436  *  FuseCollinearEdgesWithinWire
437  */
438 //=============================================================================
439 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::FuseCollinearEdgesWithinWire
440                                           (GEOM::GEOM_Object_ptr theWire,
441                                            const GEOM::ListOfGO& theVertices)
442 {
443   GEOM::GEOM_Object_var aGEOMObject;
444
445   //Set a not done flag
446   GetOperations()->SetNotDone();
447
448   //Get the reference objects
449   Handle(GEOM_Object) aWire = GetObjectImpl(theWire);
450   if (aWire.IsNull()) return aGEOMObject._retn();
451
452   int ind, aLen;
453   std::list<Handle(GEOM_Object)> aVerts;
454   //Get the shapes
455   aLen = theVertices.length();
456   for (ind = 0; ind < aLen; ind++) {
457     Handle(GEOM_Object) aSh = GetObjectImpl(theVertices[ind]);
458     if (aSh.IsNull()) return aGEOMObject._retn();
459     aVerts.push_back(aSh);
460   }
461
462   //Perform operation
463   Handle(GEOM_Object) anObject =
464     GetOperations()->FuseCollinearEdgesWithinWire(aWire, aVerts);
465   if (!GetOperations()->IsDone() || anObject.IsNull())
466     return aGEOMObject._retn();
467
468   return GetObject(anObject);
469 }
470
471 //=============================================================================
472 /*!
473  *  GetFreeBoundary
474  */
475 //=============================================================================
476 CORBA::Boolean GEOM_IHealingOperations_i::GetFreeBoundary ( GEOM::GEOM_Object_ptr theObject,
477                                                             GEOM::ListOfGO_out theClosedWires,
478                                                             GEOM::ListOfGO_out theOpenWires )
479 {
480   theClosedWires = new GEOM::ListOfGO;
481   theOpenWires = new GEOM::ListOfGO;
482
483   // Set a not done flag
484   GetOperations()->SetNotDone();
485
486   // Get the object itself
487   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
488   if (anObject.IsNull())
489     return false;
490
491   Handle(TColStd_HSequenceOfTransient) aClosed = new TColStd_HSequenceOfTransient();
492   Handle(TColStd_HSequenceOfTransient) anOpen  = new TColStd_HSequenceOfTransient();
493   bool res = GetOperations()->GetFreeBoundary( anObject, aClosed, anOpen );
494
495   if ( !GetOperations()->IsDone() || !res )
496     return false;
497
498   int i, n = aClosed->Length();
499   theClosedWires->length( n );
500   for ( i = 1; i <= n; i++ )
501     (*theClosedWires)[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aClosed->Value(i)));
502
503   n = anOpen->Length();
504   theOpenWires->length( n );
505   for ( i = 1, n = anOpen->Length(); i <= n; i++ )
506     (*theOpenWires)[i-1] = GetObject(Handle(GEOM_Object)::DownCast(anOpen->Value(i)));
507
508   return true;
509 }
510
511
512 //=============================================================================
513 /*!
514  *  ChangeOrientation
515  */
516 //=============================================================================
517 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::ChangeOrientation (GEOM::GEOM_Object_ptr theObject)
518 {
519   GEOM::GEOM_Object_var aGEOMObject;
520
521   // Set a not done flag
522   GetOperations()->SetNotDone();
523
524   // Check parameters
525   if ( CORBA::is_nil(theObject) )
526     return aGEOMObject._retn();
527
528   aGEOMObject = GEOM::GEOM_Object::_duplicate(theObject);
529
530   // Get the object itself
531   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
532   if (anObject.IsNull())
533     return aGEOMObject._retn();
534
535   // Perform
536 //  Handle(GEOM_Object) aNewObject =
537     GetOperations()->ChangeOrientation( anObject );
538 //  if (!GetOperations()->IsDone() || aNewObject.IsNull())
539 //    return aGEOMObject._retn();
540
541   //return GetObject(aNewObject);
542   return aGEOMObject._retn();
543 }
544
545
546 //=============================================================================
547 /*!
548  *  ChangeOrientationCopy
549  */
550 //=============================================================================
551 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::ChangeOrientationCopy (GEOM::GEOM_Object_ptr theObject)
552 {
553   GEOM::GEOM_Object_var aGEOMObject;
554
555   // Set a not done flag
556   GetOperations()->SetNotDone();
557
558   // Get the object itself
559   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
560   if (anObject.IsNull())
561     return aGEOMObject._retn();
562
563   // Perform
564   Handle(GEOM_Object) aNewObject =
565     GetOperations()->ChangeOrientationCopy( anObject );
566   if (!GetOperations()->IsDone() || aNewObject.IsNull())
567     return aGEOMObject._retn();
568
569   return GetObject(aNewObject);
570 }
571
572 //=============================================================================
573 /*!
574  *  LimitTolerance
575  */
576 //=============================================================================
577 GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::LimitTolerance (GEOM::GEOM_Object_ptr theObject,
578                                                                  CORBA::Double theTolerance)
579 {
580   GEOM::GEOM_Object_var aGEOMObject;
581
582   // Set a not done flag
583   GetOperations()->SetNotDone();
584
585   // Get the object itself
586   Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
587   if (anObject.IsNull())
588     return aGEOMObject._retn();
589
590   // Perform
591   Handle(GEOM_Object) aNewObject =
592     GetOperations()->LimitTolerance(anObject, theTolerance);
593   if (!GetOperations()->IsDone() || aNewObject.IsNull())
594     return aGEOMObject._retn();
595
596   return GetObject(aNewObject);
597 }