]> SALOME platform Git repositories - modules/geom.git/blob - src/GEOMImpl/GEOMImpl_I3DPrimOperations.cxx
Salome HOME
Add new command GetShapesOnBox.
[modules/geom.git] / src / GEOMImpl / GEOMImpl_I3DPrimOperations.cxx
1 // Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
3 // 
4 // This library is free software; you can redistribute it and/or
5 // modify it under the terms of the GNU Lesser General Public
6 // License as published by the Free Software Foundation; either 
7 // version 2.1 of the License.
8 // 
9 // This library is distributed in the hope that it will be useful 
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
12 // Lesser General Public License for more details.
13 //
14 // You should have received a copy of the GNU Lesser General Public  
15 // License along with this library; if not, write to the Free Software 
16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
17 //
18 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 //
20 #include <Standard_Stream.hxx>
21
22 #include <GEOMImpl_I3DPrimOperations.hxx>
23
24 #include "utilities.h"
25 #include <OpUtil.hxx>
26 #include <Utils_ExceptHandlers.hxx>
27
28 #include <TFunction_DriverTable.hxx>
29 #include <TFunction_Driver.hxx>
30 #include <TFunction_Logbook.hxx>
31 #include <TDF_Tool.hxx>
32
33 #include <GEOM_Function.hxx>
34 #include <GEOM_PythonDump.hxx>
35
36 #include <GEOMImpl_Types.hxx>
37
38 #include <GEOMImpl_BoxDriver.hxx>
39 #include <GEOMImpl_CylinderDriver.hxx>
40 #include <GEOMImpl_ConeDriver.hxx>
41 #include <GEOMImpl_SphereDriver.hxx>
42 #include <GEOMImpl_TorusDriver.hxx>
43 #include <GEOMImpl_PrismDriver.hxx>
44 #include <GEOMImpl_PipeDriver.hxx>
45 #include <GEOMImpl_RevolutionDriver.hxx>
46 #include <GEOMImpl_ShapeDriver.hxx>
47 #include <GEOMImpl_FillingDriver.hxx>
48 #include <GEOMImpl_ThruSectionsDriver.hxx>
49
50 #include <GEOMImpl_IBox.hxx>
51 #include <GEOMImpl_ICylinder.hxx>
52 #include <GEOMImpl_ICone.hxx>
53 #include <GEOMImpl_ISphere.hxx>
54 #include <GEOMImpl_ITorus.hxx>
55 #include <GEOMImpl_IPrism.hxx>
56 #include <GEOMImpl_IPipe.hxx>
57 #include <GEOMImpl_IRevolution.hxx>
58 #include <GEOMImpl_IShapes.hxx>
59 #include <GEOMImpl_IFilling.hxx>
60 #include <GEOMImpl_IThruSections.hxx>
61 #include <GEOMImpl_IPipeDiffSect.hxx>
62
63 #include <Standard_Failure.hxx>
64 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
65
66 //=============================================================================
67 /*!
68  *   constructor:
69  */
70 //=============================================================================
71 GEOMImpl_I3DPrimOperations::GEOMImpl_I3DPrimOperations (GEOM_Engine* theEngine, int theDocID)
72 : GEOM_IOperations(theEngine, theDocID)
73 {
74   MESSAGE("GEOMImpl_I3DPrimOperations::GEOMImpl_I3DPrimOperations");
75 }
76
77 //=============================================================================
78 /*!
79  *  destructor
80  */
81 //=============================================================================
82 GEOMImpl_I3DPrimOperations::~GEOMImpl_I3DPrimOperations()
83 {
84   MESSAGE("GEOMImpl_I3DPrimOperations::~GEOMImpl_I3DPrimOperations");
85 }
86
87
88 //=============================================================================
89 /*!
90  *  MakeBoxDXDYDZ
91  */
92 //=============================================================================
93 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeBoxDXDYDZ (double theDX, double theDY, double theDZ)
94 {
95   SetErrorCode(KO);
96
97   //Add a new Box object
98   Handle(GEOM_Object) aBox = GetEngine()->AddObject(GetDocID(), GEOM_BOX);
99
100   //Add a new Box function with DX_DY_DZ parameters
101   Handle(GEOM_Function) aFunction = aBox->AddFunction(GEOMImpl_BoxDriver::GetID(), BOX_DX_DY_DZ);
102   if (aFunction.IsNull()) return NULL;
103
104   //Check if the function is set correctly
105   if (aFunction->GetDriverGUID() != GEOMImpl_BoxDriver::GetID()) return NULL;
106
107   GEOMImpl_IBox aBI (aFunction);
108
109   aBI.SetDX(theDX);
110   aBI.SetDY(theDY);
111   aBI.SetDZ(theDZ);
112
113   //Compute the box value
114   try {
115 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
116     OCC_CATCH_SIGNALS;
117 #endif
118     if (!GetSolver()->ComputeFunction(aFunction)) {
119       SetErrorCode("Box driver failed");
120       return NULL;
121     }
122   }
123   catch (Standard_Failure) {
124     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
125     SetErrorCode(aFail->GetMessageString());
126     return NULL;
127   }
128
129   //Make a Python command
130   GEOM::TPythonDump(aFunction) << aBox << " = geompy.MakeBoxDXDYDZ("
131     << theDX << ", " << theDY << ", " << theDZ << ")";
132
133   SetErrorCode(OK);
134   return aBox;
135 }
136
137
138 //=============================================================================
139 /*!
140  *  MakeBoxTwoPnt
141  */
142 //=============================================================================
143 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeBoxTwoPnt (Handle(GEOM_Object) thePnt1,
144                                                                Handle(GEOM_Object) thePnt2)
145 {
146   SetErrorCode(KO);
147
148   if (thePnt1.IsNull() || thePnt2.IsNull()) return NULL;
149
150   //Add a new Box object
151   Handle(GEOM_Object) aBox = GetEngine()->AddObject(GetDocID(), GEOM_BOX);
152
153   //Add a new Box function for creation a box relatively to two points
154   Handle(GEOM_Function) aFunction = aBox->AddFunction(GEOMImpl_BoxDriver::GetID(), BOX_TWO_PNT);
155   if (aFunction.IsNull()) return NULL;
156
157   //Check if the function is set correctly
158   if (aFunction->GetDriverGUID() != GEOMImpl_BoxDriver::GetID()) return aBox;
159
160   GEOMImpl_IBox aBI (aFunction);
161
162   Handle(GEOM_Function) aRefFunction1 = thePnt1->GetLastFunction();
163   Handle(GEOM_Function) aRefFunction2 = thePnt2->GetLastFunction();
164
165   if (aRefFunction1.IsNull() || aRefFunction2.IsNull()) return aBox;
166
167   aBI.SetRef1(aRefFunction1);
168   aBI.SetRef2(aRefFunction2);
169
170   //Compute the Box value
171   try {
172 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
173     OCC_CATCH_SIGNALS;
174 #endif
175     if (!GetSolver()->ComputeFunction(aFunction)) {
176       SetErrorCode("Box driver failed");
177       return NULL;
178     }
179   }
180   catch (Standard_Failure) {
181     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
182     SetErrorCode(aFail->GetMessageString());
183     return NULL;
184   }
185
186   //Make a Python command
187   GEOM::TPythonDump(aFunction) << aBox << " = geompy.MakeBoxTwoPnt("
188     << thePnt1 << ", " << thePnt2 << ")";
189
190   SetErrorCode(OK);
191   return aBox;
192 }
193
194
195 //=============================================================================
196 /*!
197  *  MakeCylinderRH
198  */
199 //=============================================================================
200 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeCylinderRH (double theR, double theH)
201 {
202   SetErrorCode(KO);
203
204   //Add a new Cylinder object
205   Handle(GEOM_Object) aCylinder = GetEngine()->AddObject(GetDocID(), GEOM_CYLINDER);
206
207   //Add a new Cylinder function with R and H parameters
208   Handle(GEOM_Function) aFunction = aCylinder->AddFunction(GEOMImpl_CylinderDriver::GetID(), CYLINDER_R_H);
209   if (aFunction.IsNull()) return NULL;
210
211   //Check if the function is set correctly
212   if (aFunction->GetDriverGUID() != GEOMImpl_CylinderDriver::GetID()) return NULL;
213
214   GEOMImpl_ICylinder aCI (aFunction);
215
216   aCI.SetR(theR);
217   aCI.SetH(theH);
218
219   //Compute the Cylinder value
220   try {
221 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
222     OCC_CATCH_SIGNALS;
223 #endif
224     if (!GetSolver()->ComputeFunction(aFunction)) {
225       SetErrorCode("Cylinder driver failed");
226       return NULL;
227     }
228   }
229   catch (Standard_Failure) {
230     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
231     SetErrorCode(aFail->GetMessageString());
232     return NULL;
233   }
234
235   //Make a Python command
236   GEOM::TPythonDump(aFunction) << aCylinder
237     << " = geompy.MakeCylinderRH(" << theR << ", " << theH << ")";
238
239   SetErrorCode(OK);
240   return aCylinder;
241 }
242
243
244 //=============================================================================
245 /*!
246  *  MakeCylinderPntVecRH
247  */
248 //=============================================================================
249 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeCylinderPntVecRH (Handle(GEOM_Object) thePnt,
250                                                                       Handle(GEOM_Object) theVec,
251                                                                       double theR, double theH)
252 {
253   SetErrorCode(KO);
254
255   if (thePnt.IsNull() || theVec.IsNull()) return NULL;
256
257   //Add a new Cylinder object
258   Handle(GEOM_Object) aCylinder = GetEngine()->AddObject(GetDocID(), GEOM_CYLINDER);
259
260   //Add a new Cylinder function for creation a cylinder relatively to point and vector
261   Handle(GEOM_Function) aFunction =
262     aCylinder->AddFunction(GEOMImpl_CylinderDriver::GetID(), CYLINDER_PNT_VEC_R_H);
263   if (aFunction.IsNull()) return NULL;
264
265   //Check if the function is set correctly
266   if (aFunction->GetDriverGUID() != GEOMImpl_CylinderDriver::GetID()) return NULL;
267
268   GEOMImpl_ICylinder aCI (aFunction);
269
270   Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
271   Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
272
273   if (aRefPnt.IsNull() || aRefVec.IsNull()) return NULL;
274
275   aCI.SetPoint(aRefPnt);
276   aCI.SetVector(aRefVec);
277   aCI.SetR(theR);
278   aCI.SetH(theH);
279
280   //Compute the Cylinder value
281   try {
282 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
283     OCC_CATCH_SIGNALS;
284 #endif
285     if (!GetSolver()->ComputeFunction(aFunction)) {
286       SetErrorCode("Cylinder driver failed");
287       return NULL;
288     }
289   }
290   catch (Standard_Failure) {
291     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
292     SetErrorCode(aFail->GetMessageString());
293     return NULL;
294   }
295
296   //Make a Python command
297   GEOM::TPythonDump(aFunction) << aCylinder << " = geompy.MakeCylinder("
298     << thePnt << ", " << theVec << ", " << theR << ", " << theH << ")";
299
300   SetErrorCode(OK);
301   return aCylinder;
302 }
303
304
305 //=============================================================================
306 /*!
307  *  MakeConeR1R2H
308  */
309 //=============================================================================
310 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeConeR1R2H (double theR1, double theR2,
311                                                                double theH)
312 {
313   SetErrorCode(KO);
314
315   //Add a new Cone object
316   Handle(GEOM_Object) aCone = GetEngine()->AddObject(GetDocID(), GEOM_CONE);
317
318   //Add a new Cone function with R and H parameters
319   Handle(GEOM_Function) aFunction =
320     aCone->AddFunction(GEOMImpl_ConeDriver::GetID(), CONE_R1_R2_H);
321   if (aFunction.IsNull()) return NULL;
322
323   //Check if the function is set correctly
324   if (aFunction->GetDriverGUID() != GEOMImpl_ConeDriver::GetID()) return NULL;
325
326   GEOMImpl_ICone aCI (aFunction);
327
328   aCI.SetR1(theR1);
329   aCI.SetR2(theR2);
330   aCI.SetH(theH);
331
332   //Compute the Cone value
333   try {
334 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
335     OCC_CATCH_SIGNALS;
336 #endif
337     if (!GetSolver()->ComputeFunction(aFunction)) {
338       SetErrorCode("Cone driver failed");
339       return NULL;
340     }
341   }
342   catch (Standard_Failure) {
343     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
344     SetErrorCode(aFail->GetMessageString());
345     return NULL;
346   }
347
348   //Make a Python command
349   GEOM::TPythonDump(aFunction) << aCone << " = geompy.MakeConeR1R2H("
350     << theR1 << ", " << theR2 << ", " << theH << ")";
351
352   SetErrorCode(OK);
353   return aCone;
354 }
355
356
357 //=============================================================================
358 /*!
359  *  MakeConePntVecR1R2H
360  */
361 //=============================================================================
362 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeConePntVecR1R2H (Handle(GEOM_Object) thePnt,
363                                                                      Handle(GEOM_Object) theVec,
364                                                                      double theR1, double theR2,
365                                                                      double theH)
366 {
367   SetErrorCode(KO);
368
369   if (thePnt.IsNull() || theVec.IsNull()) return NULL;
370
371   //Add a new Cone object
372   Handle(GEOM_Object) aCone = GetEngine()->AddObject(GetDocID(), GEOM_CONE);
373
374   //Add a new Cone function for creation a cone relatively to point and vector
375   Handle(GEOM_Function) aFunction =
376     aCone->AddFunction(GEOMImpl_ConeDriver::GetID(), CONE_PNT_VEC_R1_R2_H);
377   if (aFunction.IsNull()) return NULL;
378
379   //Check if the function is set correctly
380   if (aFunction->GetDriverGUID() != GEOMImpl_ConeDriver::GetID()) return NULL;
381
382   GEOMImpl_ICone aCI (aFunction);
383
384   Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
385   Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
386
387   if (aRefPnt.IsNull() || aRefVec.IsNull()) return NULL;
388
389   aCI.SetPoint(aRefPnt);
390   aCI.SetVector(aRefVec);
391   aCI.SetR1(theR1);
392   aCI.SetR2(theR2);
393   aCI.SetH(theH);
394
395   //Compute the Cone value
396   try {
397 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
398     OCC_CATCH_SIGNALS;
399 #endif
400     if (!GetSolver()->ComputeFunction(aFunction)) {
401       SetErrorCode("Cone driver failed");
402       return NULL;
403     }
404   }
405   catch (Standard_Failure) {
406     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
407     SetErrorCode(aFail->GetMessageString());
408     return NULL;
409   }
410
411   //Make a Python command
412   GEOM::TPythonDump(aFunction) << aCone << " = geompy.MakeCone(" << thePnt
413     << ", " << theVec << ", " << theR1 << ", " << theR2 << ", " << theH << ")";
414
415   SetErrorCode(OK);
416   return aCone;
417 }
418
419
420 //=============================================================================
421 /*!
422  *  MakeSphereR
423  */
424 //=============================================================================
425 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeSphereR (double theR)
426 {
427   SetErrorCode(KO);
428
429   //Add a new Sphere object
430   Handle(GEOM_Object) aSphere = GetEngine()->AddObject(GetDocID(), GEOM_SPHERE);
431
432   //Add a new Sphere function with R parameter
433   Handle(GEOM_Function) aFunction = aSphere->AddFunction(GEOMImpl_SphereDriver::GetID(), SPHERE_R);
434   if (aFunction.IsNull()) return NULL;
435
436   //Check if the function is set correctly
437   if (aFunction->GetDriverGUID() != GEOMImpl_SphereDriver::GetID()) return NULL;
438
439   GEOMImpl_ISphere aCI (aFunction);
440
441   aCI.SetR(theR);
442
443   //Compute the Sphere value
444   try {
445 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
446     OCC_CATCH_SIGNALS;
447 #endif
448     if (!GetSolver()->ComputeFunction(aFunction)) {
449       SetErrorCode("Sphere driver failed");
450       return NULL;
451     }
452   }
453   catch (Standard_Failure) {
454     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
455     SetErrorCode(aFail->GetMessageString());
456     return NULL;
457   }
458
459   //Make a Python command
460   GEOM::TPythonDump(aFunction) << aSphere << " = geompy.MakeSphereR(" << theR << ")";
461
462   SetErrorCode(OK);
463   return aSphere;
464 }
465
466
467 //=============================================================================
468 /*!
469  *  MakeSpherePntR
470  */
471 //=============================================================================
472 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeSpherePntR (Handle(GEOM_Object) thePnt,
473                                                                 double theR)
474 {
475   SetErrorCode(KO);
476
477   if (thePnt.IsNull()) return NULL;
478
479   //Add a new Point object
480   Handle(GEOM_Object) aSphere = GetEngine()->AddObject(GetDocID(), GEOM_SPHERE);
481
482   //Add a new Sphere function for creation a sphere relatively to point
483   Handle(GEOM_Function) aFunction = aSphere->AddFunction(GEOMImpl_SphereDriver::GetID(), SPHERE_PNT_R);
484   if (aFunction.IsNull()) return NULL;
485
486   //Check if the function is set correctly
487   if (aFunction->GetDriverGUID() != GEOMImpl_SphereDriver::GetID()) return NULL;
488
489   GEOMImpl_ISphere aCI (aFunction);
490
491   Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
492
493   if (aRefPnt.IsNull()) return NULL;
494
495   aCI.SetPoint(aRefPnt);
496   aCI.SetR(theR);
497
498   //Compute the Sphere value
499   try {
500 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
501     OCC_CATCH_SIGNALS;
502 #endif
503     if (!GetSolver()->ComputeFunction(aFunction)) {
504       SetErrorCode("Sphere driver failed");
505       return NULL;
506     }
507   }
508   catch (Standard_Failure) {
509     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
510     SetErrorCode(aFail->GetMessageString());
511     return NULL;
512   }
513
514   //Make a Python command
515   GEOM::TPythonDump(aFunction) << aSphere
516     << " = geompy.MakeSpherePntR(" << thePnt << ", " << theR << ")";
517
518   SetErrorCode(OK);
519   return aSphere;
520 }
521
522
523 //=============================================================================
524 /*!
525  *  MakeTorusRR
526  */
527 //=============================================================================
528 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeTorusRR
529                                            (double theRMajor, double theRMinor)
530 {
531   SetErrorCode(KO);
532
533   //Add a new Torus object
534   Handle(GEOM_Object) anEll = GetEngine()->AddObject(GetDocID(), GEOM_TORUS);
535
536   //Add a new Torus function
537   Handle(GEOM_Function) aFunction =
538     anEll->AddFunction(GEOMImpl_TorusDriver::GetID(), TORUS_RR);
539   if (aFunction.IsNull()) return NULL;
540
541   //Check if the function is set correctly
542   if (aFunction->GetDriverGUID() != GEOMImpl_TorusDriver::GetID()) return NULL;
543
544   GEOMImpl_ITorus aCI (aFunction);
545
546   aCI.SetRMajor(theRMajor);
547   aCI.SetRMinor(theRMinor);
548
549   //Compute the Torus value
550   try {
551 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
552     OCC_CATCH_SIGNALS;
553 #endif
554     if (!GetSolver()->ComputeFunction(aFunction)) {
555       SetErrorCode("Torus driver failed");
556       return NULL;
557     }
558   }
559   catch (Standard_Failure) {
560     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
561     SetErrorCode(aFail->GetMessageString());
562     return NULL;
563   }
564
565   //Make a Python command
566   GEOM::TPythonDump(aFunction) << anEll << " = geompy.MakeTorusRR("
567     << theRMajor << ", " << theRMinor << ")";
568
569   SetErrorCode(OK);
570   return anEll;
571 }
572
573 //=============================================================================
574 /*!
575  *  MakeTorusPntVecRR
576  */
577 //=============================================================================
578 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeTorusPntVecRR
579                        (Handle(GEOM_Object) thePnt, Handle(GEOM_Object) theVec,
580                         double theRMajor, double theRMinor)
581 {
582   SetErrorCode(KO);
583
584   if (thePnt.IsNull() || theVec.IsNull()) return NULL;
585
586   //Add a new Torus object
587   Handle(GEOM_Object) anEll = GetEngine()->AddObject(GetDocID(), GEOM_TORUS);
588
589   //Add a new Torus function
590   Handle(GEOM_Function) aFunction =
591     anEll->AddFunction(GEOMImpl_TorusDriver::GetID(), TORUS_PNT_VEC_RR);
592   if (aFunction.IsNull()) return NULL;
593
594   //Check if the function is set correctly
595   if (aFunction->GetDriverGUID() != GEOMImpl_TorusDriver::GetID()) return NULL;
596
597   GEOMImpl_ITorus aCI (aFunction);
598
599   Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
600   Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
601
602   if (aRefPnt.IsNull() || aRefVec.IsNull()) return NULL;
603
604   aCI.SetCenter(aRefPnt);
605   aCI.SetVector(aRefVec);
606   aCI.SetRMajor(theRMajor);
607   aCI.SetRMinor(theRMinor);
608
609   //Compute the Torus value
610   try {
611 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
612     OCC_CATCH_SIGNALS;
613 #endif
614     if (!GetSolver()->ComputeFunction(aFunction)) {
615       SetErrorCode("Torus driver failed");
616       return NULL;
617     }
618   }
619   catch (Standard_Failure) {
620     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
621     SetErrorCode(aFail->GetMessageString());
622     return NULL;
623   }
624
625   //Make a Python command
626   GEOM::TPythonDump(aFunction) << anEll << " = geompy.MakeTorus(" << thePnt
627     << ", " << theVec << ", " << theRMajor << ", " << theRMinor << ")";
628
629   SetErrorCode(OK);
630   return anEll;
631 }
632
633
634 //=============================================================================
635 /*!
636  *  MakePrismVecH
637  */
638 //=============================================================================
639 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePrismVecH (Handle(GEOM_Object) theBase,
640                                                                Handle(GEOM_Object) theVec,
641                                                                double theH)
642 {
643   SetErrorCode(KO);
644
645   if (theBase.IsNull() || theVec.IsNull()) return NULL;
646
647   //Add a new Prism object
648   Handle(GEOM_Object) aPrism = GetEngine()->AddObject(GetDocID(), GEOM_PRISM);
649
650   //Add a new Prism function for creation a Prism relatively to vector
651   Handle(GEOM_Function) aFunction =
652     aPrism->AddFunction(GEOMImpl_PrismDriver::GetID(), PRISM_BASE_VEC_H);
653   if (aFunction.IsNull()) return NULL;
654
655   //Check if the function is set correctly
656   if (aFunction->GetDriverGUID() != GEOMImpl_PrismDriver::GetID()) return NULL;
657
658   GEOMImpl_IPrism aCI (aFunction);
659
660   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
661   Handle(GEOM_Function) aRefVec  = theVec->GetLastFunction();
662
663   if (aRefBase.IsNull() || aRefVec.IsNull()) return NULL;
664
665   aCI.SetBase(aRefBase);
666   aCI.SetVector(aRefVec);
667   aCI.SetH(theH);
668
669   //Compute the Prism value
670   try {
671 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
672     OCC_CATCH_SIGNALS;
673 #endif
674     if (!GetSolver()->ComputeFunction(aFunction)) {
675       //SetErrorCode("Prism driver failed");
676       SetErrorCode("Extrusion can not be created, check input data");
677       return NULL;
678     }
679   }
680   catch (Standard_Failure) {
681     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
682     SetErrorCode(aFail->GetMessageString());
683     return NULL;
684   }
685
686   //Make a Python command
687   GEOM::TPythonDump(aFunction) << aPrism << " = geompy.MakePrismVecH("
688     << theBase << ", " << theVec << ", " << theH << ")";
689
690   SetErrorCode(OK);
691   return aPrism;
692 }
693
694 //=============================================================================
695 /*!
696  *  MakePrismTwoPnt
697  */
698 //=============================================================================
699 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePrismTwoPnt
700        (Handle(GEOM_Object) theBase,
701         Handle(GEOM_Object) thePoint1, Handle(GEOM_Object) thePoint2)
702 {
703   SetErrorCode(KO);
704
705   if (theBase.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
706
707   //Add a new Prism object
708   Handle(GEOM_Object) aPrism = GetEngine()->AddObject(GetDocID(), GEOM_PRISM);
709
710   //Add a new Prism function for creation a Prism relatively to two points
711   Handle(GEOM_Function) aFunction =
712     aPrism->AddFunction(GEOMImpl_PrismDriver::GetID(), PRISM_BASE_TWO_PNT);
713   if (aFunction.IsNull()) return NULL;
714
715   //Check if the function is set correctly
716   if (aFunction->GetDriverGUID() != GEOMImpl_PrismDriver::GetID()) return NULL;
717
718   GEOMImpl_IPrism aCI (aFunction);
719
720   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
721   Handle(GEOM_Function) aRefPnt1 = thePoint1->GetLastFunction();
722   Handle(GEOM_Function) aRefPnt2 = thePoint2->GetLastFunction();
723
724   if (aRefBase.IsNull() || aRefPnt1.IsNull() || aRefPnt2.IsNull()) return NULL;
725
726   aCI.SetBase(aRefBase);
727   aCI.SetFirstPoint(aRefPnt1);
728   aCI.SetLastPoint(aRefPnt2);
729
730   //Compute the Prism value
731   try {
732 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
733     OCC_CATCH_SIGNALS;
734 #endif
735     if (!GetSolver()->ComputeFunction(aFunction)) {
736       //SetErrorCode("Prism driver failed");
737       SetErrorCode("Extrusion can not be created, check input data");
738       return NULL;
739     }
740   }
741   catch (Standard_Failure) {
742     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
743     SetErrorCode(aFail->GetMessageString());
744     return NULL;
745   }
746
747   //Make a Python command
748   GEOM::TPythonDump(aFunction) << aPrism << " = geompy.MakePrism("
749     << theBase << ", " << thePoint1 << ", " << thePoint2 << ")";
750
751   SetErrorCode(OK);
752   return aPrism;
753 }
754
755
756 //=============================================================================
757 /*!
758  *  MakePipe
759  */
760 //=============================================================================
761 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipe (Handle(GEOM_Object) theBase,
762                                                           Handle(GEOM_Object) thePath)
763 {
764   SetErrorCode(KO);
765
766   if (theBase.IsNull() || thePath.IsNull()) return NULL;
767
768   //Add a new Pipe object
769   Handle(GEOM_Object) aPipe = GetEngine()->AddObject(GetDocID(), GEOM_PIPE);
770
771   //Add a new Pipe function
772   Handle(GEOM_Function) aFunction =
773     aPipe->AddFunction(GEOMImpl_PipeDriver::GetID(), PIPE_BASE_PATH);
774   if (aFunction.IsNull()) return NULL;
775
776   //Check if the function is set correctly
777   if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return NULL;
778
779   GEOMImpl_IPipe aCI (aFunction);
780
781   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
782   Handle(GEOM_Function) aRefPath = thePath->GetLastFunction();
783
784   if (aRefBase.IsNull() || aRefPath.IsNull()) return NULL;
785
786   aCI.SetBase(aRefBase);
787   aCI.SetPath(aRefPath);
788
789   //Compute the Pipe value
790   try {
791 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
792     OCC_CATCH_SIGNALS;
793 #endif
794     if (!GetSolver()->ComputeFunction(aFunction)) {
795       SetErrorCode("Pipe driver failed");
796       return NULL;
797     }
798   }
799   catch (Standard_Failure) {
800     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
801     SetErrorCode(aFail->GetMessageString());
802     return NULL;
803   }
804
805   //Make a Python command
806   GEOM::TPythonDump(aFunction) << aPipe << " = geompy.MakePipe("
807     << theBase << ", " << thePath << ")";
808
809   SetErrorCode(OK);
810   return aPipe;
811 }
812
813
814 //=============================================================================
815 /*!
816  *  MakeRevolutionAxisAngle
817  */
818 //=============================================================================
819 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeRevolutionAxisAngle (Handle(GEOM_Object) theBase,
820                                                                          Handle(GEOM_Object) theAxis,
821                                                                          double theAngle)
822 {
823   SetErrorCode(KO);
824
825   if (theBase.IsNull() || theAxis.IsNull()) return NULL;
826
827   //Add a new Revolution object
828   Handle(GEOM_Object) aRevolution = GetEngine()->AddObject(GetDocID(), GEOM_REVOLUTION);
829
830   //Add a new Revolution function for creation a revolution relatively to axis
831   Handle(GEOM_Function) aFunction =
832     aRevolution->AddFunction(GEOMImpl_RevolutionDriver::GetID(), REVOLUTION_BASE_AXIS_ANGLE);
833   if (aFunction.IsNull()) return NULL;
834
835   //Check if the function is set correctly
836   if (aFunction->GetDriverGUID() != GEOMImpl_RevolutionDriver::GetID()) return NULL;
837
838   GEOMImpl_IRevolution aCI (aFunction);
839
840   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
841   Handle(GEOM_Function) aRefAxis = theAxis->GetLastFunction();
842
843   if (aRefBase.IsNull() || aRefAxis.IsNull()) return NULL;
844
845   aCI.SetBase(aRefBase);
846   aCI.SetAxis(aRefAxis);
847   aCI.SetAngle(theAngle);
848
849   //Compute the Revolution value
850   try {
851 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
852     OCC_CATCH_SIGNALS;
853 #endif
854     if (!GetSolver()->ComputeFunction(aFunction)) {
855       SetErrorCode("Revolution driver failed");
856       return NULL;
857     }
858   }
859   catch (Standard_Failure) {
860     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
861     SetErrorCode(aFail->GetMessageString());
862     return NULL;
863   }
864
865   //Make a Python command
866   GEOM::TPythonDump(aFunction) << aRevolution << " = geompy.MakeRevolution("
867     << theBase << ", " << theAxis << ", " << theAngle * 180.0 / PI << "*math.pi/180.0)";
868
869   SetErrorCode(OK);
870   return aRevolution;
871 }
872
873
874 //=============================================================================
875 /*!
876  *  MakeSolidShell
877  */
878 //=============================================================================
879 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeSolidShell (Handle(GEOM_Object) theShell)
880 {
881   SetErrorCode(KO);
882
883   if (theShell.IsNull()) return NULL;
884
885   //Add a new Solid object
886   Handle(GEOM_Object) aSolid = GetEngine()->AddObject(GetDocID(), GEOM_SOLID);
887
888   //Add a new Solid function for creation a solid from a shell
889   Handle(GEOM_Function) aFunction =
890     aSolid->AddFunction(GEOMImpl_ShapeDriver::GetID(), SOLID_SHELL);
891   if (aFunction.IsNull()) return NULL;
892
893   //Check if the function is set correctly
894   if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) return NULL;
895
896   GEOMImpl_IShapes aCI (aFunction);
897
898   Handle(GEOM_Function) aRefShell = theShell->GetLastFunction();
899
900   if (aRefShell.IsNull()) return NULL;
901
902   aCI.SetBase(aRefShell);
903
904   //Compute the Solid value
905   try {
906 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
907     OCC_CATCH_SIGNALS;
908 #endif
909     if (!GetSolver()->ComputeFunction(aFunction)) {
910       SetErrorCode("Solid driver failed");
911       return NULL;
912     }
913   }
914   catch (Standard_Failure) {
915     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
916     SetErrorCode(aFail->GetMessageString());
917     return NULL;
918   }
919
920   //Make a Python command
921   GEOM::TPythonDump(aFunction) << aSolid << " = geompy.MakeSolid(" << theShell << ")";
922
923   SetErrorCode(OK);
924   return aSolid;
925 }
926
927 //=============================================================================
928 /*!
929  *  MakeFilling
930  */
931 //=============================================================================
932 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeFilling
933        (Handle(GEOM_Object) theShape, int theMinDeg, int theMaxDeg,
934         double theTol2D, double theTol3D, int theNbIter)
935 {
936   SetErrorCode(KO);
937
938   if (theShape.IsNull()) return NULL;
939
940   //Add a new Filling object
941   Handle(GEOM_Object) aFilling = GetEngine()->AddObject(GetDocID(), GEOM_FILLING);
942
943   //Add a new Filling function for creation a filling  from a compound
944   Handle(GEOM_Function) aFunction = aFilling->AddFunction(GEOMImpl_FillingDriver::GetID(), BASIC_FILLING);
945   if (aFunction.IsNull()) return NULL;
946
947   //Check if the function is set correctly
948   if (aFunction->GetDriverGUID() != GEOMImpl_FillingDriver::GetID()) return NULL;
949
950   GEOMImpl_IFilling aFI (aFunction);
951
952   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
953
954   if (aRefShape.IsNull()) return NULL;
955
956   aFI.SetShape(aRefShape);
957   aFI.SetMinDeg(theMinDeg);
958   aFI.SetMaxDeg(theMaxDeg);
959   aFI.SetTol2D(theTol2D);
960   aFI.SetTol3D(theTol3D);
961   aFI.SetNbIter(theNbIter);
962
963   //Compute the Solid value
964   try {
965 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
966     OCC_CATCH_SIGNALS;
967 #endif
968     if (!GetSolver()->ComputeFunction(aFunction)) {
969       SetErrorCode("Filling driver failed");
970       return NULL;
971     }
972   }
973   catch (Standard_Failure) {
974     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
975     if (strcmp(aFail->GetMessageString(), "Geom_BSplineSurface") == 0)
976       SetErrorCode("B-Spline surface construction failed");
977     else
978       SetErrorCode(aFail->GetMessageString());
979     return NULL;
980   }
981
982   //Make a Python command
983   GEOM::TPythonDump(aFunction) << aFilling << " = geompy.MakeFilling("
984     << theShape << ", " << theMinDeg << ", " << theMaxDeg << ", "
985       << theTol2D << ", " << theTol3D << ", " << theNbIter << ")";
986
987   SetErrorCode(OK);
988   return aFilling;
989 }
990
991 //=============================================================================
992 /*!
993  *  MakeThruSections
994  */
995 //=============================================================================
996 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeThruSections(
997                                                 const Handle(TColStd_HSequenceOfTransient)& theSeqSections,
998                                                 bool theModeSolid,
999                                                 double thePreci,
1000                                                 bool theRuled)
1001 {
1002   Handle(GEOM_Object) anObj;
1003   SetErrorCode(KO);
1004   if(theSeqSections.IsNull())
1005     return anObj;
1006
1007   Standard_Integer nbObj = theSeqSections->Length();
1008   if (!nbObj) 
1009     return anObj;
1010
1011   //Add a new ThruSections object
1012   Handle(GEOM_Object) aThruSect = GetEngine()->AddObject(GetDocID(), GEOM_THRUSECTIONS);
1013
1014  
1015   //Add a new ThruSections function
1016
1017   int aTypeFunc = (theRuled ? THRUSECTIONS_RULED : THRUSECTIONS_SMOOTHED);
1018   Handle(GEOM_Function) aFunction =
1019     aThruSect->AddFunction(GEOMImpl_ThruSectionsDriver::GetID(), aTypeFunc);
1020   if (aFunction.IsNull()) return anObj;
1021
1022   //Check if the function is set correctly
1023   if (aFunction->GetDriverGUID() != GEOMImpl_ThruSectionsDriver::GetID()) return NULL;
1024
1025   GEOMImpl_IThruSections aCI (aFunction);
1026
1027   Handle(TColStd_HSequenceOfTransient) aSeqSections = new TColStd_HSequenceOfTransient;
1028
1029   Standard_Integer i =1;
1030   for( ; i <= nbObj; i++) {
1031
1032     Handle(Standard_Transient) anItem = theSeqSections->Value(i);
1033     if(anItem.IsNull())
1034       continue;
1035     
1036     Handle(GEOM_Object) aSectObj = Handle(GEOM_Object)::DownCast(anItem);
1037     if(!aSectObj.IsNull())
1038     {
1039       Handle(GEOM_Function) aRefSect = aSectObj->GetLastFunction();
1040       if(!aRefSect.IsNull())
1041         aSeqSections->Append(aRefSect);
1042     }
1043   }
1044
1045   if(!aSeqSections->Length())
1046     return anObj;
1047
1048   aCI.SetSections(aSeqSections);
1049   aCI.SetSolidMode(theModeSolid);
1050   aCI.SetPrecision(thePreci);
1051
1052   //Compute the ThruSections value
1053   try {
1054 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1055     OCC_CATCH_SIGNALS;
1056 #endif
1057     if (!GetSolver()->ComputeFunction(aFunction)) {
1058       SetErrorCode("ThruSections driver failed");
1059       return anObj;
1060     }
1061   }
1062   catch (Standard_Failure) {
1063     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1064     SetErrorCode(aFail->GetMessageString());
1065     return anObj;
1066   }
1067
1068   //Make a Python command
1069   GEOM::TPythonDump pyDump(aFunction);
1070   pyDump << aThruSect << " = geompy.MakeThruSections([";
1071
1072   for(i =1 ; i <= nbObj; i++) {
1073
1074     Handle(Standard_Transient) anItem = theSeqSections->Value(i);
1075     if(anItem.IsNull())
1076       continue;
1077     
1078     Handle(GEOM_Object) aSectObj = Handle(GEOM_Object)::DownCast(anItem);
1079     if(!aSectObj.IsNull()) {
1080       pyDump<< aSectObj;
1081       if(i < nbObj)
1082         pyDump<<", ";
1083     }
1084   }
1085   
1086   pyDump<< "],"<<theModeSolid << "," << thePreci <<","<< theRuled <<")";
1087
1088   SetErrorCode(OK);
1089   return aThruSect;
1090   
1091    
1092 }
1093
1094 //=============================================================================
1095 /*!
1096  *  MakePipeWithDifferentSections
1097  */
1098 //=============================================================================
1099 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithDifferentSections(
1100                                                 const Handle(TColStd_HSequenceOfTransient)& theBases,
1101                                                 const Handle(TColStd_HSequenceOfTransient)& theLocations,
1102                                                 const Handle(GEOM_Object)& thePath,
1103                                                 bool theWithContact,
1104                                                 bool theWithCorrections)
1105 {
1106   Handle(GEOM_Object) anObj;
1107   SetErrorCode(KO);
1108   if(theBases.IsNull())
1109     return anObj;
1110
1111   Standard_Integer nbBases = theBases->Length();
1112   
1113   if (!nbBases)
1114     return anObj;
1115   
1116   Standard_Integer nbLocs =  (theLocations.IsNull() ? 0 :theLocations->Length());
1117   //Add a new Pipe object
1118   Handle(GEOM_Object) aPipeDS = GetEngine()->AddObject(GetDocID(), GEOM_PIPE);
1119  
1120   //Add a new Pipe function
1121
1122   Handle(GEOM_Function) aFunction =
1123     aPipeDS->AddFunction(GEOMImpl_PipeDriver::GetID(), PIPE_DIFFERENT_SECTIONS);
1124   if (aFunction.IsNull()) return anObj;
1125
1126   //Check if the function is set correctly
1127   if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return anObj;
1128
1129   GEOMImpl_IPipeDiffSect aCI (aFunction);
1130
1131   Handle(GEOM_Function) aRefPath = thePath->GetLastFunction();
1132   if(aRefPath.IsNull())
1133     return anObj;
1134
1135   Handle(TColStd_HSequenceOfTransient) aSeqBases = new TColStd_HSequenceOfTransient;
1136   Handle(TColStd_HSequenceOfTransient) aSeqLocs = new TColStd_HSequenceOfTransient;
1137
1138   Standard_Integer i =1;
1139   for( ; i <= nbBases; i++) {
1140
1141     Handle(Standard_Transient) anItem = theBases->Value(i);
1142     if(anItem.IsNull())
1143       continue;
1144     
1145     Handle(GEOM_Object) aBase = Handle(GEOM_Object)::DownCast(anItem);
1146     if(aBase.IsNull())
1147       continue;
1148     Handle(GEOM_Function) aRefBase = aBase->GetLastFunction();
1149     if(aRefBase.IsNull())
1150       continue;
1151     if(nbLocs)
1152     {
1153       Handle(Standard_Transient) anItemLoc = theLocations->Value(i);
1154       if(anItemLoc.IsNull())
1155         continue;
1156     
1157       Handle(GEOM_Object) aLoc = Handle(GEOM_Object)::DownCast(anItemLoc);
1158       if(aLoc.IsNull())
1159         continue;
1160       Handle(GEOM_Function) aRefLoc = aLoc->GetLastFunction();
1161       if(aRefLoc.IsNull())
1162         continue;
1163       aSeqLocs->Append(aRefLoc);
1164     }
1165     aSeqBases->Append(aRefBase);
1166   }
1167
1168   if(!aSeqBases->Length())
1169     return anObj;
1170
1171   aCI.SetBases(aSeqBases);
1172   aCI.SetLocations(aSeqLocs);
1173   aCI.SetPath(aRefPath);
1174   aCI.SetWithContactMode(theWithContact);
1175   aCI.SetWithCorrectionMode(theWithCorrections);
1176   
1177   //Compute the Pipe value
1178   try {
1179 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1180     OCC_CATCH_SIGNALS;
1181 #endif
1182     if (!GetSolver()->ComputeFunction(aFunction)) {
1183       SetErrorCode("Pipe with defferent section driver failed");
1184       return anObj;
1185     }
1186   }
1187   catch (Standard_Failure) {
1188     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1189     SetErrorCode(aFail->GetMessageString());
1190     return anObj;
1191   }
1192
1193   //Make a Python command
1194   GEOM::TPythonDump pyDump(aFunction);
1195   pyDump << aPipeDS << " = geompy.MakePipeWithDifferentSections([";
1196
1197   for(i =1 ; i <= nbBases; i++) {
1198
1199     Handle(Standard_Transient) anItem = theBases->Value(i);
1200     if(anItem.IsNull())
1201       continue;
1202     
1203     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(anItem);
1204     if(!anObj.IsNull()) {
1205       pyDump<< anObj;
1206       if(i < nbBases)
1207         pyDump<<", ";
1208     }
1209     
1210   }
1211   
1212   pyDump<< "], [";
1213    
1214   for(i =1 ; i <= nbLocs; i++) {
1215
1216     Handle(Standard_Transient) anItem = theLocations->Value(i);
1217     if(anItem.IsNull())
1218       continue;
1219     
1220     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(anItem);
1221     if(!anObj.IsNull()) {
1222       pyDump<< anObj;
1223       if(i < nbLocs)
1224         pyDump<<", ";
1225     }
1226   }  
1227
1228   pyDump<< "], "<<thePath<<","<<theWithContact << "," << theWithCorrections<<")";
1229
1230   SetErrorCode(OK);
1231   return aPipeDS;
1232   
1233    
1234 }