]> SALOME platform Git repositories - modules/geom.git/blob - src/GEOMImpl/GEOMImpl_ITransformOperations.cxx
Salome HOME
Add new command GetShapesOnBox.
[modules/geom.git] / src / GEOMImpl / GEOMImpl_ITransformOperations.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_ITransformOperations.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_TranslateDriver.hxx>
37 #include <GEOMImpl_MirrorDriver.hxx>
38 #include <GEOMImpl_OffsetDriver.hxx>
39 #include <GEOMImpl_ScaleDriver.hxx>
40 #include <GEOMImpl_RotateDriver.hxx>
41 #include <GEOMImpl_PositionDriver.hxx>
42
43 #include <GEOMImpl_ITranslate.hxx>
44 #include <GEOMImpl_IMirror.hxx>
45 #include <GEOMImpl_IOffset.hxx>
46 #include <GEOMImpl_IScale.hxx>
47 #include <GEOMImpl_IRotate.hxx>
48 #include <GEOMImpl_IPosition.hxx>
49
50 #include <GEOMImpl_Types.hxx>
51
52 #include <Standard_Failure.hxx>
53 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
54
55 //=============================================================================
56 /*!
57  *   constructor:
58  */
59 //=============================================================================
60
61 GEOMImpl_ITransformOperations::GEOMImpl_ITransformOperations (GEOM_Engine* theEngine, int theDocID)
62 : GEOM_IOperations(theEngine, theDocID)
63 {
64   MESSAGE("GEOMImpl_ITransformOperations::GEOMImpl_ITransformOperations");
65 }
66
67 //=============================================================================
68 /*!
69  *  destructor
70  */
71 //=============================================================================
72
73 GEOMImpl_ITransformOperations::~GEOMImpl_ITransformOperations()
74 {
75   MESSAGE("GEOMImpl_ITransformOperations::~GEOMImpl_ITransformOperations");
76 }
77
78
79 //=============================================================================
80 /*!
81  *  TranslateTwoPoints
82  */
83 //=============================================================================
84 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateTwoPoints
85        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint1, Handle(GEOM_Object) thePoint2)
86 {
87   SetErrorCode(KO);
88
89   if (theObject.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
90
91   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
92   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
93
94   // Get last functions of the arguments
95   Handle(GEOM_Function) aP1F = thePoint1->GetLastFunction();
96   Handle(GEOM_Function) aP2F = thePoint2->GetLastFunction();
97
98   //Add a translate function
99   aFunction = theObject->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_TWO_POINTS);
100
101   if (aFunction.IsNull()) return NULL;
102
103   //Check if the function is set correctly
104   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
105
106   GEOMImpl_ITranslate aTI (aFunction);
107   aTI.SetPoint1(aP1F);
108   aTI.SetPoint2(aP2F);
109   aTI.SetOriginal(aLastFunction);
110
111   //Compute the translation
112   try {
113 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
114     OCC_CATCH_SIGNALS;
115 #endif
116     if (!GetSolver()->ComputeFunction(aFunction)) {
117       SetErrorCode("Translation driver failed");
118       return NULL;
119     }
120   }
121   catch (Standard_Failure) {
122     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
123     SetErrorCode(aFail->GetMessageString());
124     return NULL;
125   }
126
127   //Make a Python command
128   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.TranslateTwoPoints("
129     << theObject << ", " << thePoint1 << ", " << thePoint2 << ")";
130
131   SetErrorCode(OK);
132   return theObject;
133 }
134
135 //=============================================================================
136 /*!
137  *  TranslateDXDYDZ
138  */
139 //=============================================================================
140 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateDXDYDZ
141        (Handle(GEOM_Object) theObject, double theX, double theY,  double theZ)
142 {
143   SetErrorCode(KO);
144
145   if (theObject.IsNull()) return NULL;
146
147   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
148   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
149
150   //Add a translate function
151   aFunction = theObject->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_XYZ);
152
153   if (aFunction.IsNull()) return NULL;
154
155   //Check if the function is set correctly
156   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
157
158   GEOMImpl_ITranslate aTI(aFunction);
159   aTI.SetDX(theX);
160   aTI.SetDY(theY);
161   aTI.SetDZ(theZ);
162   aTI.SetOriginal(aLastFunction);
163
164   //Compute the translation
165   try {
166 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
167     OCC_CATCH_SIGNALS;
168 #endif
169     if (!GetSolver()->ComputeFunction(aFunction)) {
170       SetErrorCode("Translation driver failed");
171       return NULL;
172     }
173   }
174   catch (Standard_Failure) {
175     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
176     SetErrorCode(aFail->GetMessageString());
177     return NULL;
178   }
179
180   //Make a Python command
181   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.TranslateDXDYDZ("
182     << theObject << ", " << theX << ", " << theY << ", " << theZ << ")";
183
184   SetErrorCode(OK);
185   return theObject;
186 }
187
188
189 //=============================================================================
190 /*!
191  *  TranslateTwoPointsCopy
192  */
193 //=============================================================================
194 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateTwoPointsCopy
195        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint1, Handle(GEOM_Object) thePoint2)
196 {
197   SetErrorCode(KO);
198
199   if (theObject.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
200
201   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
202   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
203
204   //Add a new Copy object
205   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
206
207   //Add a translate function
208   Handle(GEOM_Function) aFunction =
209     aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_TWO_POINTS_COPY);
210
211   //Check if the function is set correctly
212   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
213
214   GEOMImpl_ITranslate aTI(aFunction);
215   aTI.SetPoint1(thePoint1->GetLastFunction());
216   aTI.SetPoint2(thePoint2->GetLastFunction());
217   //aTI.SetShape(theObject->GetValue());
218   aTI.SetOriginal(aLastFunction);
219
220   //Compute the translation
221   try {
222 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
223     OCC_CATCH_SIGNALS;
224 #endif
225     if (!GetSolver()->ComputeFunction(aFunction)) {
226       SetErrorCode("Translation driver failed");
227       return NULL;
228     }
229   }
230   catch (Standard_Failure) {
231     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
232     SetErrorCode(aFail->GetMessageString());
233     return NULL;
234   }
235
236   //Make a Python command
237   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeTranslationTwoPoints("
238     << theObject << ", " << thePoint1 << ", " << thePoint2 << ")";
239
240   SetErrorCode(OK);
241   return aCopy;
242 }
243
244 //=============================================================================
245 /*!
246  *  TranslateDXDYDZCopy
247  */
248 //=============================================================================
249 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateDXDYDZCopy
250        (Handle(GEOM_Object) theObject, double theX, double theY,  double theZ)
251 {
252   SetErrorCode(KO);
253
254   if (theObject.IsNull()) return NULL;
255
256   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
257   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
258
259   //Add a new Copy object
260   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
261
262   //Add a translate function
263   Handle(GEOM_Function) aFunction =
264     aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_XYZ_COPY);
265
266   //Check if the function is set correctly
267   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
268
269   GEOMImpl_ITranslate aTI(aFunction);
270   aTI.SetDX(theX);
271   aTI.SetDY(theY);
272   aTI.SetDZ(theZ);
273   aTI.SetOriginal(aLastFunction);
274
275   //Compute the translation
276   try {
277 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
278     OCC_CATCH_SIGNALS;
279 #endif
280     if (!GetSolver()->ComputeFunction(aFunction)) {
281       SetErrorCode("Translation driver failed");
282       return NULL;
283     }
284   }
285   catch (Standard_Failure) {
286     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
287     SetErrorCode(aFail->GetMessageString());
288     return NULL;
289   }
290
291   //Make a Python command
292   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeTranslation("
293     << theObject << ", " << theX << ", " << theY << ", " << theZ << ")";
294
295   SetErrorCode(OK);
296   return aCopy;
297 }
298
299
300 //=============================================================================
301 /*!
302  *  TranslateVector
303  */
304 //=============================================================================
305 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateVector
306        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector)
307 {
308   SetErrorCode(KO);
309
310   if (theObject.IsNull() || theVector.IsNull()) return NULL;
311
312   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
313   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
314
315   // Get last functions of the arguments
316   Handle(GEOM_Function) aVF = theVector->GetLastFunction();
317
318   //Add a translate function
319   aFunction = theObject->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_VECTOR);
320
321   if (aFunction.IsNull()) return NULL;
322
323   //Check if the function is set correctly
324   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
325
326   GEOMImpl_ITranslate aTI (aFunction);
327   aTI.SetVector(aVF);
328   aTI.SetOriginal(aLastFunction);
329
330   //Compute the translation
331   try {
332 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
333     OCC_CATCH_SIGNALS;
334 #endif
335     if (!GetSolver()->ComputeFunction(aFunction)) {
336       SetErrorCode("Translation driver failed");
337       return NULL;
338     }
339   }
340   catch (Standard_Failure) {
341     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
342     SetErrorCode(aFail->GetMessageString());
343     return NULL;
344   }
345
346   //Make a Python command
347   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.TranslateVector("
348                                << theObject << ", " << theVector << ")";
349
350   SetErrorCode(OK);
351   return theObject;
352 }
353
354 //=============================================================================
355 /*!
356  *  TranslateVectorCopy
357  */
358 //=============================================================================
359 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateVectorCopy
360        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector)
361 {
362   SetErrorCode(KO);
363
364   if (theObject.IsNull() || theVector.IsNull()) return NULL;
365
366   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
367   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
368
369   //Add a new Copy object
370   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
371
372   //Add a translate function
373   Handle(GEOM_Function) aFunction =
374     aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_VECTOR_COPY);
375
376   //Check if the function is set correctly
377   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
378
379   GEOMImpl_ITranslate aTI(aFunction);
380   aTI.SetVector(theVector->GetLastFunction());
381 //  aTI.SetShape(theObject->GetValue());
382   aTI.SetOriginal(aLastFunction);
383
384   //Compute the translation
385   try {
386 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
387     OCC_CATCH_SIGNALS;
388 #endif
389     if (!GetSolver()->ComputeFunction(aFunction)) {
390       SetErrorCode("Translation driver failed");
391       return NULL;
392     }
393   }
394   catch (Standard_Failure) {
395     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
396     SetErrorCode(aFail->GetMessageString());
397     return NULL;
398   }
399
400   //Make a Python command
401   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeTranslationVector("
402                                << theObject << ", " << theVector << ")";
403
404   SetErrorCode(OK);
405   return aCopy;
406 }
407
408 //=============================================================================
409 /*!
410  *  Translate1D
411  */
412 //=============================================================================
413 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Translate1D
414        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector,
415         double theStep, Standard_Integer theNbTimes)
416 {
417   SetErrorCode(KO);
418
419   if (theObject.IsNull() || theVector.IsNull()) return NULL;
420
421   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
422   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
423
424   //Add a new Copy object
425   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
426
427   //Add a translate function
428   Handle(GEOM_Function) aFunction =
429     aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_1D);
430
431   //Check if the function is set correctly
432   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
433
434   GEOMImpl_ITranslate aTI(aFunction);
435   aTI.SetVector(theVector->GetLastFunction());
436   aTI.SetOriginal(aLastFunction);
437   aTI.SetStep1(theStep);
438   aTI.SetNbIter1(theNbTimes);
439
440   //Compute the translation
441   try {
442 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
443     OCC_CATCH_SIGNALS;
444 #endif
445     if (!GetSolver()->ComputeFunction(aFunction)) {
446       SetErrorCode("Translation driver failed");
447       return NULL;
448     }
449   }
450   catch (Standard_Failure) {
451     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
452     SetErrorCode(aFail->GetMessageString());
453     return NULL;
454   }
455
456   //Make a Python command
457   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeMultiTranslation1D("
458     << theObject << ", " << theVector << ", " << theStep << ", " << theNbTimes << ")";
459
460   SetErrorCode(OK);
461   return aCopy;
462 }
463
464 //=============================================================================
465 /*!
466  *  Translate2D
467  */
468 //=============================================================================
469 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Translate2D (Handle(GEOM_Object) theObject,
470                                                                 Handle(GEOM_Object) theVector,
471                                                                 double theStep1,
472                                                                 Standard_Integer theNbTimes1,
473                                                                 Handle(GEOM_Object) theVector2,
474                                                                 double theStep2,
475                                                                 Standard_Integer theNbTimes2)
476 {
477   SetErrorCode(KO);
478
479   if (theObject.IsNull() || theVector.IsNull() || theVector2.IsNull()) return NULL;
480
481   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
482   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
483
484   //Add a new Copy object
485   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
486
487   //Add a translate function
488   Handle(GEOM_Function) aFunction =
489     aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_2D);
490
491   //Check if the function is set correctly
492   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
493
494   GEOMImpl_ITranslate aTI(aFunction);
495   aTI.SetVector(theVector->GetLastFunction());
496   aTI.SetVector2(theVector2->GetLastFunction());
497   aTI.SetOriginal(aLastFunction);
498   aTI.SetStep1(theStep1);
499   aTI.SetNbIter1(theNbTimes1);
500   aTI.SetStep2(theStep2);
501   aTI.SetNbIter2(theNbTimes2);
502
503   //Compute the translation
504   try {
505 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
506     OCC_CATCH_SIGNALS;
507 #endif
508     if (!GetSolver()->ComputeFunction(aFunction)) {
509       SetErrorCode("Translation driver failed");
510       return NULL;
511     }
512   }
513   catch (Standard_Failure) {
514     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
515     SetErrorCode(aFail->GetMessageString());
516     return NULL;
517   }
518
519   //Make a Python command
520   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeMultiTranslation2D("
521     << theObject << ", " << theVector  << ", " << theStep1 << ", " << theNbTimes1
522       << ", " << theVector2 << ", " << theStep2 << ", " << theNbTimes2 << ")";
523
524   SetErrorCode(OK);
525   return aCopy;
526 }
527
528
529 //=============================================================================
530 /*!
531  *  MirrorPlane
532  */
533 //=============================================================================
534 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorPlane
535        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePlane)
536 {
537   SetErrorCode(KO);
538
539   if (theObject.IsNull() || thePlane.IsNull()) return NULL;
540
541   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
542   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be mirrored
543
544   // Get last functions of the arguments
545   Handle(GEOM_Function) aPF = thePlane->GetLastFunction();
546
547   //Add a mirror function
548   Handle(GEOM_Function) aFunction =
549     theObject->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_PLANE);
550   if (aFunction.IsNull()) return NULL;
551
552   //Check if the function is set correctly
553   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
554
555   GEOMImpl_IMirror aTI (aFunction);
556   aTI.SetPlane(aPF);
557   aTI.SetOriginal(aLastFunction);
558
559   //Compute the mirror
560   try {
561 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
562     OCC_CATCH_SIGNALS;
563 #endif
564     if (!GetSolver()->ComputeFunction(aFunction)) {
565       SetErrorCode("Mirror driver failed");
566       return NULL;
567     }
568   }
569   catch (Standard_Failure) {
570     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
571     SetErrorCode(aFail->GetMessageString());
572     return NULL;
573   }
574
575   //Make a Python command
576   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.MirrorPlane("
577                                << theObject << ", " << thePlane << ")";
578
579   SetErrorCode(OK);
580   return theObject;
581 }
582
583 //=============================================================================
584 /*!
585  *  MirrorPlaneCopy
586  */
587 //=============================================================================
588 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorPlaneCopy
589        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePlane)
590 {
591   SetErrorCode(KO);
592
593   if (theObject.IsNull() || thePlane.IsNull()) return NULL;
594
595   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
596   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be mirrored
597
598   //Add a new Copy object
599   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
600
601   //Add a mirror function
602   Handle(GEOM_Function) aFunction =
603     aCopy->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_PLANE_COPY);
604
605   //Check if the function is set correctly
606   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
607
608   GEOMImpl_IMirror aTI (aFunction);
609   aTI.SetPlane(thePlane->GetLastFunction());
610   aTI.SetOriginal(aLastFunction);
611
612   //Compute the mirror
613   try {
614 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
615     OCC_CATCH_SIGNALS;
616 #endif
617     if (!GetSolver()->ComputeFunction(aFunction)) {
618       SetErrorCode("Mirror driver failed");
619       return NULL;
620     }
621   }
622   catch (Standard_Failure) {
623     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
624     SetErrorCode(aFail->GetMessageString());
625     return NULL;
626   }
627
628   //Make a Python command
629   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeMirrorByPlane("
630                                << theObject << ", " << thePlane << ")";
631
632   SetErrorCode(OK);
633   return aCopy;
634 }
635
636 //=============================================================================
637 /*!
638  *  MirrorPoint
639  */
640 //=============================================================================
641 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorPoint
642        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint)
643 {
644   SetErrorCode(KO);
645
646   if (theObject.IsNull() || thePoint.IsNull()) return NULL;
647
648   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
649   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be mirrored
650
651   // Get last functions of the arguments
652   Handle(GEOM_Function) aPF = thePoint->GetLastFunction();
653
654   //Add a mirror function
655   Handle(GEOM_Function) aFunction =
656     theObject->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_POINT);
657   if (aFunction.IsNull()) return NULL;
658
659   //Check if the function is set correctly
660   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
661
662   GEOMImpl_IMirror aTI (aFunction);
663   aTI.SetPoint(aPF);
664   aTI.SetOriginal(aLastFunction);
665
666   //Compute the mirror
667   try {
668 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
669     OCC_CATCH_SIGNALS;
670 #endif
671     if (!GetSolver()->ComputeFunction(aFunction)) {
672       SetErrorCode("Mirror driver failed");
673       return NULL;
674     }
675   }
676   catch (Standard_Failure) {
677     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
678     SetErrorCode(aFail->GetMessageString());
679     return NULL;
680   }
681
682   //Make a Python command
683   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.MirrorPoint("
684                                << theObject << ", " << thePoint << ")";
685
686   SetErrorCode(OK);
687   return NULL;
688 }
689
690 //=============================================================================
691 /*!
692  *  MirrorPointCopy
693  */
694 //=============================================================================
695 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorPointCopy
696        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint)
697 {
698   SetErrorCode(KO);
699
700   if (theObject.IsNull() || thePoint.IsNull()) return NULL;
701
702   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
703   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be mirrored
704
705   //Add a new Copy object
706   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
707
708   //Add a mirror function
709   Handle(GEOM_Function) aFunction =
710     aCopy->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_POINT_COPY);
711
712   //Check if the function is set correctly
713   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
714
715   GEOMImpl_IMirror aTI (aFunction);
716   aTI.SetPoint(thePoint->GetLastFunction());
717   aTI.SetOriginal(aLastFunction);
718
719   //Compute the mirror
720   try {
721 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
722     OCC_CATCH_SIGNALS;
723 #endif
724     if (!GetSolver()->ComputeFunction(aFunction)) {
725       SetErrorCode("Mirror driver failed");
726       return NULL;
727     }
728   }
729   catch (Standard_Failure) {
730     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
731     SetErrorCode(aFail->GetMessageString());
732     return NULL;
733   }
734
735   //Make a Python command
736   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeMirrorByPoint("
737                                << theObject << ", " << thePoint << ")";
738
739   SetErrorCode(OK);
740   return aCopy;
741 }
742
743 //=============================================================================
744 /*!
745  *  MirrorAxis
746  */
747 //=============================================================================
748 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorAxis
749        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis)
750 {
751   SetErrorCode(KO);
752
753   if (theObject.IsNull() || theAxis.IsNull()) return NULL;
754
755   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
756   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be mirrored
757
758   // Get last functions of the arguments
759   Handle(GEOM_Function) anAF = theAxis->GetLastFunction();
760
761   //Add a mirror function
762   Handle(GEOM_Function) aFunction =
763     theObject->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_AXIS);
764   if (aFunction.IsNull()) return NULL;
765
766   //Check if the function is set correctly
767   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
768
769   GEOMImpl_IMirror aTI (aFunction);
770   aTI.SetAxis(anAF);
771   aTI.SetOriginal(aLastFunction);
772
773   //Compute the mirror
774   try {
775 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
776     OCC_CATCH_SIGNALS;
777 #endif
778     if (!GetSolver()->ComputeFunction(aFunction)) {
779       SetErrorCode("Mirror driver failed");
780       return NULL;
781     }
782   }
783   catch (Standard_Failure) {
784     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
785     SetErrorCode(aFail->GetMessageString());
786     return NULL;
787   }
788
789   //Make a Python command
790   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.MirrorAxis("
791                                << theObject << ", " << theAxis << ")";
792
793   SetErrorCode(OK);
794   return NULL;
795 }
796
797 //=============================================================================
798 /*!
799  *  MirrorAxisCopy
800  */
801 //=============================================================================
802 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorAxisCopy
803        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis)
804 {
805   SetErrorCode(KO);
806
807   if (theObject.IsNull() || theAxis.IsNull()) return NULL;
808
809   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
810   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be mirrored
811
812   //Add a new Copy object
813   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
814
815   //Add a mirror function
816   Handle(GEOM_Function) aFunction =
817     aCopy->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_AXIS_COPY);
818
819   //Check if the function is set correctly
820   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
821
822   GEOMImpl_IMirror aTI (aFunction);
823   aTI.SetAxis(theAxis->GetLastFunction());
824   aTI.SetOriginal(aLastFunction);
825
826   //Compute the mirror
827   try {
828 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
829     OCC_CATCH_SIGNALS;
830 #endif
831     if (!GetSolver()->ComputeFunction(aFunction)) {
832       SetErrorCode("Mirror driver failed");
833       return NULL;
834     }
835   }
836   catch (Standard_Failure) {
837     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
838     SetErrorCode(aFail->GetMessageString());
839     return NULL;
840   }
841
842   //Make a Python command
843   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeMirrorByAxis("
844                                << theObject << ", " << theAxis << ")";
845
846   SetErrorCode(OK);
847   return aCopy;
848 }
849
850
851 //=============================================================================
852 /*!
853  *  OffsetShape
854  */
855 //=============================================================================
856 Handle(GEOM_Object) GEOMImpl_ITransformOperations::OffsetShape
857                               (Handle(GEOM_Object) theObject, double theOffset)
858 {
859   SetErrorCode(KO);
860
861   if (theObject.IsNull()) return NULL;
862
863   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
864   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be offset
865
866   //Add a new Offset function
867   Handle(GEOM_Function) aFunction =
868     theObject->AddFunction(GEOMImpl_OffsetDriver::GetID(), OFFSET_SHAPE);
869   if (aFunction.IsNull()) return NULL;
870
871   //Check if the function is set correctly
872   if (aFunction->GetDriverGUID() != GEOMImpl_OffsetDriver::GetID()) return NULL;
873
874   GEOMImpl_IOffset aTI (aFunction);
875   aTI.SetShape(anOriginal);
876   aTI.SetValue(theOffset);
877
878   //Compute the offset
879   try {
880 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
881     OCC_CATCH_SIGNALS;
882 #endif
883     if (!GetSolver()->ComputeFunction(aFunction)) {
884       SetErrorCode("Offset driver failed");
885       return NULL;
886     }
887   }
888   catch (Standard_Failure) {
889     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
890     SetErrorCode(aFail->GetMessageString());
891     return NULL;
892   }
893
894   //Make a Python command
895   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.OffsetShape("
896                                << theObject << ", " << theOffset << ")";
897
898   SetErrorCode(OK);
899   return theObject;
900 }
901
902 //=============================================================================
903 /*!
904  *  OffsetShapeCopy
905  */
906 //=============================================================================
907 Handle(GEOM_Object) GEOMImpl_ITransformOperations::OffsetShapeCopy
908                               (Handle(GEOM_Object) theObject, double theOffset)
909 {
910   SetErrorCode(KO);
911
912   if (theObject.IsNull()) return NULL;
913
914   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
915   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be offset
916
917   //Add a new Copy object
918   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
919
920   //Add a new Offset function
921   Handle(GEOM_Function) aFunction =
922     aCopy->AddFunction(GEOMImpl_OffsetDriver::GetID(), OFFSET_SHAPE_COPY);
923   if (aFunction.IsNull()) return NULL;
924
925   //Check if the function is set correctly
926   if (aFunction->GetDriverGUID() != GEOMImpl_OffsetDriver::GetID()) return NULL;
927
928   GEOMImpl_IOffset aTI (aFunction);
929   aTI.SetShape(anOriginal);
930   aTI.SetValue(theOffset);
931
932   //Compute the offset
933   try {
934 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
935     OCC_CATCH_SIGNALS;
936 #endif
937     if (!GetSolver()->ComputeFunction(aFunction)) {
938       SetErrorCode("Offset driver failed");
939       return NULL;
940     }
941   }
942   catch (Standard_Failure) {
943     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
944     SetErrorCode(aFail->GetMessageString());
945     return NULL;
946   }
947
948   //Make a Python command
949   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeOffset("
950                                << theObject << ", " << theOffset << ")";
951
952   SetErrorCode(OK);
953   return aCopy;
954 }
955
956
957 //=============================================================================
958 /*!
959  *  ScaleShape
960  */
961 //=============================================================================
962 Handle(GEOM_Object) GEOMImpl_ITransformOperations::ScaleShape
963        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint, double theFactor)
964 {
965   SetErrorCode(KO);
966
967   if (theObject.IsNull() || thePoint.IsNull()) return NULL;
968
969   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
970   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be scaled
971
972   // Get last functions of the arguments
973   Handle(GEOM_Function) aPF = thePoint->GetLastFunction();
974
975   //Add a scale function
976   Handle(GEOM_Function) aFunction =
977     theObject->AddFunction(GEOMImpl_ScaleDriver::GetID(), SCALE_SHAPE);
978   if (aFunction.IsNull()) return NULL;
979
980   //Check if the function is set correctly
981   if (aFunction->GetDriverGUID() != GEOMImpl_ScaleDriver::GetID()) return NULL;
982
983   GEOMImpl_IScale aTI (aFunction);
984   aTI.SetShape(anOriginal);
985   aTI.SetPoint(aPF);
986   aTI.SetFactor(theFactor);
987
988   //Compute the scale
989   try {
990 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
991     OCC_CATCH_SIGNALS;
992 #endif
993     if (!GetSolver()->ComputeFunction(aFunction)) {
994       SetErrorCode("Scale driver failed");
995       return NULL;
996     }
997   }
998   catch (Standard_Failure) {
999     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1000     SetErrorCode(aFail->GetMessageString());
1001     return NULL;
1002   }
1003
1004   //Make a Python command
1005   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.ScaleShape("
1006     << theObject << ", " << thePoint << ", " << theFactor << ")";
1007
1008   SetErrorCode(OK);
1009   return theObject;
1010 }
1011
1012 //=============================================================================
1013 /*!
1014  *  ScaleShapeCopy
1015  */
1016 //=============================================================================
1017 Handle(GEOM_Object) GEOMImpl_ITransformOperations::ScaleShapeCopy
1018        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint, double theFactor)
1019 {
1020   SetErrorCode(KO);
1021
1022   if (theObject.IsNull() || thePoint.IsNull()) return NULL;
1023
1024   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1025   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be scaled
1026
1027   //Add a new Copy object
1028   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1029
1030   //Add a scale function
1031   Handle(GEOM_Function) aFunction =
1032     aCopy->AddFunction(GEOMImpl_ScaleDriver::GetID(), SCALE_SHAPE_COPY);
1033   if (aFunction.IsNull()) return NULL;
1034
1035   //Check if the function is set correctly
1036   if (aFunction->GetDriverGUID() != GEOMImpl_ScaleDriver::GetID()) return NULL;
1037
1038   GEOMImpl_IScale aTI (aFunction);
1039   aTI.SetShape(anOriginal);
1040   aTI.SetPoint(thePoint->GetLastFunction());
1041   aTI.SetFactor(theFactor);
1042
1043   //Compute the scale
1044   try {
1045 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1046     OCC_CATCH_SIGNALS;
1047 #endif
1048     if (!GetSolver()->ComputeFunction(aFunction)) {
1049       SetErrorCode("Scale driver failed");
1050       return NULL;
1051     }
1052   }
1053   catch (Standard_Failure) {
1054     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1055     SetErrorCode(aFail->GetMessageString());
1056     return NULL;
1057   }
1058
1059   //Make a Python command
1060   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeScaleTransform("
1061     << theObject << ", " << thePoint << ", " << theFactor << ")";
1062
1063   SetErrorCode(OK);
1064   return aCopy;
1065 }
1066
1067 //=============================================================================
1068 /*!
1069  *  PositionShape
1070  */
1071 //=============================================================================
1072 Handle(GEOM_Object) GEOMImpl_ITransformOperations::PositionShape
1073         (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theStartLCS, Handle(GEOM_Object) theEndLCS)
1074 {
1075   SetErrorCode(KO);
1076
1077   if (theObject.IsNull() || theEndLCS.IsNull()) return NULL;
1078
1079   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1080   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be set in position
1081
1082   //Add a Position function
1083   Standard_Integer aType = POSITION_SHAPE;
1084   if (theStartLCS.IsNull()) aType = POSITION_SHAPE_FROM_GLOBAL;
1085
1086   Handle(GEOM_Function) aFunction =
1087     theObject->AddFunction(GEOMImpl_PositionDriver::GetID(), aType);
1088   if (aFunction.IsNull()) return NULL;
1089
1090   //Check if the function is set correctly
1091   if (aFunction->GetDriverGUID() != GEOMImpl_PositionDriver::GetID()) return NULL;
1092
1093   //Set operation arguments
1094   GEOMImpl_IPosition aTI (aFunction);
1095   aTI.SetShape(anOriginal);
1096   aTI.SetEndLCS(theEndLCS->GetLastFunction());
1097   if (!theStartLCS.IsNull())
1098     aTI.SetStartLCS(theStartLCS->GetLastFunction());
1099
1100   //Compute the Position
1101   try {
1102 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1103     OCC_CATCH_SIGNALS;
1104 #endif
1105     if (!GetSolver()->ComputeFunction(aFunction)) {
1106       SetErrorCode("Position driver failed");
1107       return NULL;
1108     }
1109   }
1110   catch (Standard_Failure) {
1111     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1112     SetErrorCode(aFail->GetMessageString());
1113     return NULL;
1114   }
1115
1116   //Make a Python command
1117   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.PositionShape("
1118     << theObject << ", " << theStartLCS << ", " << theEndLCS << ")";
1119
1120   SetErrorCode(OK);
1121   return theObject;
1122 }
1123
1124 //=============================================================================
1125 /*!
1126  *  PositionShapeCopy
1127  */
1128 //=============================================================================
1129 Handle(GEOM_Object) GEOMImpl_ITransformOperations::PositionShapeCopy
1130        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theStartLCS, Handle(GEOM_Object) theEndLCS)
1131 {
1132   SetErrorCode(KO);
1133
1134   if (theObject.IsNull() || theEndLCS.IsNull()) return NULL;
1135
1136   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1137   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be set in position
1138
1139   //Add a new Copy object
1140   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1141
1142   //Add a position function
1143   Standard_Integer aType = POSITION_SHAPE_COPY;
1144   if (theStartLCS.IsNull()) aType = POSITION_SHAPE_FROM_GLOBAL_COPY;
1145
1146   Handle(GEOM_Function) aFunction =
1147     aCopy->AddFunction(GEOMImpl_PositionDriver::GetID(), aType);
1148   if (aFunction.IsNull()) return NULL;
1149
1150   //Check if the function is set correctly
1151   if (aFunction->GetDriverGUID() != GEOMImpl_PositionDriver::GetID()) return NULL;
1152
1153   GEOMImpl_IPosition aTI (aFunction);
1154   aTI.SetShape(anOriginal);
1155   aTI.SetEndLCS(theEndLCS->GetLastFunction());
1156   if (!theStartLCS.IsNull())
1157     aTI.SetStartLCS(theStartLCS->GetLastFunction());
1158
1159   //Compute the position
1160   try {
1161 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1162     OCC_CATCH_SIGNALS;
1163 #endif
1164     if (!GetSolver()->ComputeFunction(aFunction)) {
1165       SetErrorCode("Position driver failed");
1166       return NULL;
1167     }
1168   }
1169   catch (Standard_Failure) {
1170     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1171     SetErrorCode(aFail->GetMessageString());
1172     return NULL;
1173   }
1174
1175   //Make a Python command
1176   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakePosition("
1177     << theObject << ", " << theStartLCS << ", " << theEndLCS << ")";
1178
1179   SetErrorCode(OK);
1180   return aCopy;
1181 }
1182
1183 //=============================================================================
1184 /*!
1185  *  Rotate
1186  */
1187 //=============================================================================
1188 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Rotate (Handle(GEOM_Object) theObject,
1189                                                            Handle(GEOM_Object) theAxis,
1190                                                            double theAngle)
1191 {
1192   SetErrorCode(KO);
1193
1194   if (theObject.IsNull() || theAxis.IsNull()) return NULL;
1195
1196   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1197   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1198
1199   // Get last functions of the arguments
1200   Handle(GEOM_Function) anAF = theAxis->GetLastFunction();
1201
1202   //Add a rotate function
1203   aFunction = theObject->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE);
1204
1205   if (aFunction.IsNull()) return NULL;
1206
1207   //Check if the function is set correctly
1208   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1209
1210   GEOMImpl_IRotate aRI(aFunction);
1211   aRI.SetAxis(anAF);
1212   aRI.SetOriginal(aLastFunction);
1213   aRI.SetAngle(theAngle);
1214
1215   //Compute the translation
1216   try {
1217 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1218     OCC_CATCH_SIGNALS;
1219 #endif
1220     if (!GetSolver()->ComputeFunction(aFunction)) {
1221       SetErrorCode("Rotate driver failed");
1222       return NULL;
1223     }
1224   }
1225   catch (Standard_Failure) {
1226     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1227     SetErrorCode(aFail->GetMessageString());
1228     return NULL;
1229   }
1230
1231   //Make a Python command
1232   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.Rotate(" << theObject
1233     << ", " << theAxis << ", " << theAngle * 180.0 / PI << "*math.pi/180.0)";
1234
1235   SetErrorCode(OK);
1236   return theObject;
1237 }
1238
1239 //=============================================================================
1240 /*!
1241  *  Rotate
1242  */
1243 //=============================================================================
1244 Handle(GEOM_Object) GEOMImpl_ITransformOperations::RotateCopy (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis, double theAngle)
1245 {
1246   SetErrorCode(KO);
1247
1248   if (theObject.IsNull() || theAxis.IsNull()) return NULL;
1249
1250   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1251   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1252
1253   //Add a new Copy object
1254   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1255
1256   //Add a rotate function
1257   aFunction = aCopy->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_COPY);
1258   if (aFunction.IsNull()) return NULL;
1259
1260     //Check if the function is set correctly
1261   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1262
1263   GEOMImpl_IRotate aRI(aFunction);
1264   aRI.SetAxis(theAxis->GetLastFunction());
1265   aRI.SetOriginal(aLastFunction);
1266   aRI.SetAngle(theAngle);
1267
1268   //Compute the translation
1269   try {
1270 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1271     OCC_CATCH_SIGNALS;
1272 #endif
1273     if (!GetSolver()->ComputeFunction(aFunction)) {
1274       SetErrorCode("Rotate driver failed");
1275       return NULL;
1276     }
1277   }
1278   catch (Standard_Failure) {
1279     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1280     SetErrorCode(aFail->GetMessageString());
1281     return NULL;
1282   }
1283
1284   //Make a Python command
1285   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeRotation(" << theObject
1286     << ", " << theAxis << ", " << theAngle * 180.0 / PI << "*math.pi/180.0)";
1287
1288   SetErrorCode(OK);
1289   return aCopy;
1290 }
1291
1292 //=============================================================================
1293 /*!
1294  *  Rotate1D
1295  */
1296 //=============================================================================
1297 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Rotate1D (Handle(GEOM_Object) theObject,
1298                                                              Handle(GEOM_Object) theAxis,
1299                                                              Standard_Integer theNbTimes)
1300 {
1301   SetErrorCode(KO);
1302
1303   if (theObject.IsNull() || theAxis.IsNull()) return NULL;
1304
1305   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1306   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1307
1308   //Add a new Copy object
1309   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1310
1311   //Add a rotate function
1312   aFunction = aCopy->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_1D);
1313   if (aFunction.IsNull()) return NULL;
1314
1315     //Check if the function is set correctly
1316   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1317
1318   GEOMImpl_IRotate aRI(aFunction);
1319   aRI.SetOriginal(aLastFunction);
1320   aRI.SetAxis(theAxis->GetLastFunction());
1321   aRI.SetNbIter1(theNbTimes);
1322
1323   //Compute the translation
1324   try {
1325 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1326     OCC_CATCH_SIGNALS;
1327 #endif
1328     if (!GetSolver()->ComputeFunction(aFunction)) {
1329       SetErrorCode("Rotate driver failed");
1330       return NULL;
1331     }
1332   }
1333   catch (Standard_Failure) {
1334     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1335     SetErrorCode(aFail->GetMessageString());
1336     return NULL;
1337   }
1338
1339   //Make a Python command
1340   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MultiRotate1D("
1341     << theObject << ", " << theAxis << ", " << theNbTimes << ")";
1342
1343   SetErrorCode(OK);
1344   return aCopy;
1345 }
1346
1347 //=============================================================================
1348 /*!
1349  *  Rotate2D
1350  */
1351 //=============================================================================
1352 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Rotate2D (Handle(GEOM_Object) theObject,
1353                                                              Handle(GEOM_Object) theAxis,
1354                                                              double theAngle,
1355                                                              Standard_Integer theNbTimes1,
1356                                                              double theStep,
1357                                                              Standard_Integer theNbTimes2)
1358 {
1359   SetErrorCode(KO);
1360
1361   if (theObject.IsNull() || theAxis.IsNull()) return NULL;
1362
1363   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1364   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1365
1366   //Add a new Copy object
1367   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1368
1369   //Add a rotate function
1370   aFunction = aCopy->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_2D);
1371   if (aFunction.IsNull()) return NULL;
1372
1373     //Check if the function is set correctly
1374   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1375
1376   GEOMImpl_IRotate aRI(aFunction);
1377   aRI.SetAxis(theAxis->GetLastFunction());
1378   aRI.SetOriginal(aLastFunction);
1379   aRI.SetNbIter1(theNbTimes1);
1380   aRI.SetNbIter2(theNbTimes2);
1381   aRI.SetAngle(theAngle);
1382   aRI.SetStep(theStep);
1383
1384   //Compute the translation
1385   try {
1386 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1387     OCC_CATCH_SIGNALS;
1388 #endif
1389     if (!GetSolver()->ComputeFunction(aFunction)) {
1390       SetErrorCode("Rotate driver failed");
1391       return NULL;
1392     }
1393   }
1394   catch (Standard_Failure) {
1395     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1396     SetErrorCode(aFail->GetMessageString());
1397     return NULL;
1398   }
1399
1400   //Make a Python command
1401   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MultiRotate2D("
1402     << theObject << ", " << theAxis << ", " << theAngle << ", "
1403       << theNbTimes1 << ", " << theStep << ", " << theNbTimes2 << ")";
1404
1405   SetErrorCode(OK);
1406   return aCopy;
1407 }
1408
1409 //=============================================================================
1410 /*!
1411  *  RotateThreePoints
1412  */
1413 //=============================================================================
1414 Handle(GEOM_Object) GEOMImpl_ITransformOperations::RotateThreePoints (Handle(GEOM_Object) theObject,
1415                                                                       Handle(GEOM_Object) theCentPoint, 
1416                                                                       Handle(GEOM_Object) thePoint1,
1417                                                                       Handle(GEOM_Object) thePoint2)
1418 {
1419   SetErrorCode(KO);
1420
1421   if (theObject.IsNull() || theCentPoint.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
1422
1423   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1424   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1425
1426   // Get last functions of the arguments
1427   Handle(GEOM_Function) aCPF = theCentPoint->GetLastFunction();
1428   Handle(GEOM_Function) aP1F = thePoint1->GetLastFunction();
1429   Handle(GEOM_Function) aP2F = thePoint2->GetLastFunction();
1430
1431
1432   //Add a rotate function
1433   aFunction = theObject->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_THREE_POINTS);
1434
1435   if (aFunction.IsNull()) return NULL;
1436
1437   //Check if the function is set correctly
1438   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1439
1440   GEOMImpl_IRotate aRI(aFunction);
1441   aRI.SetCentPoint(aCPF);
1442   aRI.SetPoint1(aP1F);
1443   aRI.SetPoint2(aP2F);
1444   aRI.SetOriginal(aLastFunction);
1445
1446   //Compute the translation
1447   try {
1448 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1449     OCC_CATCH_SIGNALS;
1450 #endif
1451     if (!GetSolver()->ComputeFunction(aFunction)) {
1452       SetErrorCode("Rotate driver failed");
1453       return NULL;
1454     }
1455   }
1456   catch (Standard_Failure) {
1457     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1458     SetErrorCode(aFail->GetMessageString());
1459     return NULL;
1460   }
1461
1462   //Make a Python command
1463   GEOM::TPythonDump(aFunction) << "geompy.TrsfOp.RotateThreePoints(" << theObject
1464                                << ", " << theCentPoint << ", "<<thePoint1 << ", " << thePoint2 << ")";
1465
1466   SetErrorCode(OK);
1467   return theObject;
1468 }
1469
1470 //=============================================================================
1471 /*!
1472  *  RotateThreePointsCopy
1473  */
1474 //=============================================================================
1475 Handle(GEOM_Object) GEOMImpl_ITransformOperations::RotateThreePointsCopy (Handle(GEOM_Object) theObject, 
1476                                                          Handle(GEOM_Object) theCentPoint, 
1477                                                          Handle(GEOM_Object) thePoint1,
1478                                                          Handle(GEOM_Object) thePoint2)
1479 {
1480   SetErrorCode(KO);
1481
1482   if (theObject.IsNull() || theCentPoint.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
1483
1484   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1485   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1486
1487   //Add a new Copy object
1488   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1489
1490   //Add a rotate function
1491   aFunction = aCopy->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_THREE_POINTS_COPY);
1492   if (aFunction.IsNull()) return NULL;
1493
1494     //Check if the function is set correctly
1495   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1496
1497   GEOMImpl_IRotate aRI(aFunction);
1498   aRI.SetCentPoint(theCentPoint->GetLastFunction());
1499   aRI.SetPoint1(thePoint1->GetLastFunction());
1500   aRI.SetPoint2(thePoint2->GetLastFunction());
1501   aRI.SetOriginal(aLastFunction);
1502
1503   //Compute the translation
1504   try {
1505 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1506     OCC_CATCH_SIGNALS;
1507 #endif
1508     if (!GetSolver()->ComputeFunction(aFunction)) {
1509       SetErrorCode("Rotate driver failed");
1510       return NULL;
1511     }
1512   }
1513   catch (Standard_Failure) {
1514     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1515     SetErrorCode(aFail->GetMessageString());
1516     return NULL;
1517   }
1518
1519   //Make a Python command
1520   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeRotationThreePoints(" << theObject
1521                                << ", " << theCentPoint << ", "<<thePoint1 << ", " << thePoint2 << ")";
1522
1523   SetErrorCode(OK);
1524   return aCopy;
1525 }
1526