]> SALOME platform Git repositories - modules/geom.git/blob - src/GEOMImpl/GEOMImpl_ITransformOperations.cxx
Salome HOME
XAO test fixed to work in salome test
[modules/geom.git] / src / GEOMImpl / GEOMImpl_ITransformOperations.cxx
1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 #include <Standard_Stream.hxx>
24
25 #include <GEOMImpl_ITransformOperations.hxx>
26
27 #include <GEOMImpl_TranslateDriver.hxx>
28 #include <GEOMImpl_MirrorDriver.hxx>
29 #include <GEOMImpl_ProjectionDriver.hxx>
30 #include <GEOMImpl_OffsetDriver.hxx>
31 #include <GEOMImpl_ScaleDriver.hxx>
32 #include <GEOMImpl_RotateDriver.hxx>
33 #include <GEOMImpl_PositionDriver.hxx>
34
35 #include <GEOMImpl_ITranslate.hxx>
36 #include <GEOMImpl_IMirror.hxx>
37 #include <GEOMImpl_IProjection.hxx>
38 #include <GEOMImpl_IProjOnCyl.hxx>
39 #include <GEOMImpl_IOffset.hxx>
40 #include <GEOMImpl_IScale.hxx>
41 #include <GEOMImpl_IRotate.hxx>
42 #include <GEOMImpl_IPosition.hxx>
43
44 #include <GEOMImpl_Types.hxx>
45
46 #include <GEOM_Function.hxx>
47 #include <GEOM_PythonDump.hxx>
48
49 #include <Basics_OCCTVersion.hxx>
50
51 #include "utilities.h"
52 #include <OpUtil.hxx>
53 #include <Utils_ExceptHandlers.hxx>
54
55 #include <TFunction_DriverTable.hxx>
56 #include <TFunction_Driver.hxx>
57 #include <TDF_Tool.hxx>
58
59 #include <BRep_Tool.hxx>
60 #include <BRep_Builder.hxx>
61 #include <TopExp.hxx>
62 #include <TopoDS.hxx>
63 #include <TopoDS_Edge.hxx>
64 #include <TopoDS_Vertex.hxx>
65 #include <TopoDS_Compound.hxx>
66 #include <gp_Pnt.hxx>
67 #include <gp_Vec.hxx>
68 #include <gp_Trsf.hxx>
69
70 #include <StdFail_NotDone.hxx>
71 #include <Standard_Failure.hxx>
72 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
73
74 //=============================================================================
75 /*!
76  *   constructor:
77  */
78 //=============================================================================
79
80 GEOMImpl_ITransformOperations::GEOMImpl_ITransformOperations (GEOM_Engine* theEngine, int theDocID)
81 : GEOM_IOperations(theEngine, theDocID)
82 {
83   MESSAGE("GEOMImpl_ITransformOperations::GEOMImpl_ITransformOperations");
84 }
85
86 //=============================================================================
87 /*!
88  *  destructor
89  */
90 //=============================================================================
91
92 GEOMImpl_ITransformOperations::~GEOMImpl_ITransformOperations()
93 {
94   MESSAGE("GEOMImpl_ITransformOperations::~GEOMImpl_ITransformOperations");
95 }
96
97
98 //=============================================================================
99 /*!
100  *  TranslateTwoPoints
101  */
102 //=============================================================================
103 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateTwoPoints
104        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint1, Handle(GEOM_Object) thePoint2)
105 {
106   SetErrorCode(KO);
107
108   if (theObject.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
109
110   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
111   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
112
113   // Get last functions of the arguments
114   Handle(GEOM_Function) aP1F = thePoint1->GetLastFunction();
115   Handle(GEOM_Function) aP2F = thePoint2->GetLastFunction();
116
117   //Add a translate function
118   aFunction = theObject->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_TWO_POINTS);
119
120   if (aFunction.IsNull()) return NULL;
121
122   //Check if the function is set correctly
123   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
124
125   GEOMImpl_ITranslate aTI (aFunction);
126   aTI.SetPoint1(aP1F);
127   aTI.SetPoint2(aP2F);
128   aTI.SetOriginal(aLastFunction);
129
130   //Compute the translation
131   try {
132     OCC_CATCH_SIGNALS;
133     if (!GetSolver()->ComputeFunction(aFunction)) {
134       SetErrorCode("Translation driver failed");
135       return NULL;
136     }
137   }
138   catch (Standard_Failure) {
139     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
140     SetErrorCode(aFail->GetMessageString());
141     return NULL;
142   }
143
144   //Make a Python command
145   GEOM::TPythonDump(aFunction) << "geompy.TranslateTwoPoints("
146     << theObject << ", " << thePoint1 << ", " << thePoint2 << ")";
147
148   SetErrorCode(OK);
149   return theObject;
150 }
151
152 //=============================================================================
153 /*!
154  *  TranslateDXDYDZ
155  */
156 //=============================================================================
157 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateDXDYDZ
158        (Handle(GEOM_Object) theObject, double theX, double theY,  double theZ)
159 {
160   SetErrorCode(KO);
161
162   if (theObject.IsNull()) return NULL;
163
164   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
165   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
166
167   //Add a translate function
168   aFunction = theObject->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_XYZ);
169
170   if (aFunction.IsNull()) return NULL;
171
172   //Check if the function is set correctly
173   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
174
175   GEOMImpl_ITranslate aTI(aFunction);
176   aTI.SetDX(theX);
177   aTI.SetDY(theY);
178   aTI.SetDZ(theZ);
179   aTI.SetOriginal(aLastFunction);
180
181   //Compute the translation
182   try {
183     OCC_CATCH_SIGNALS;
184     if (!GetSolver()->ComputeFunction(aFunction)) {
185       SetErrorCode("Translation driver failed");
186       return NULL;
187     }
188   }
189   catch (Standard_Failure) {
190     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
191     SetErrorCode(aFail->GetMessageString());
192     return NULL;
193   }
194
195   //Make a Python command
196   GEOM::TPythonDump(aFunction) << "geompy.TranslateDXDYDZ("
197     << theObject << ", " << theX << ", " << theY << ", " << theZ << ")";
198
199   SetErrorCode(OK);
200   return theObject;
201 }
202
203
204 //=============================================================================
205 /*!
206  *  TranslateTwoPointsCopy
207  */
208 //=============================================================================
209 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateTwoPointsCopy
210        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint1, Handle(GEOM_Object) thePoint2)
211 {
212   SetErrorCode(KO);
213
214   if (theObject.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
215
216   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
217   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
218
219   //Add a new Copy object
220   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
221
222   //Add a translate function
223   Handle(GEOM_Function) aFunction =
224     aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_TWO_POINTS_COPY);
225
226   //Check if the function is set correctly
227   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
228
229   GEOMImpl_ITranslate aTI(aFunction);
230   aTI.SetPoint1(thePoint1->GetLastFunction());
231   aTI.SetPoint2(thePoint2->GetLastFunction());
232   //aTI.SetShape(theObject->GetValue());
233   aTI.SetOriginal(aLastFunction);
234
235   //Compute the translation
236   try {
237     OCC_CATCH_SIGNALS;
238     if (!GetSolver()->ComputeFunction(aFunction)) {
239       SetErrorCode("Translation driver failed");
240       return NULL;
241     }
242   }
243   catch (Standard_Failure) {
244     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
245     SetErrorCode(aFail->GetMessageString());
246     return NULL;
247   }
248
249   //Make a Python command
250   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeTranslationTwoPoints("
251     << theObject << ", " << thePoint1 << ", " << thePoint2 << ")";
252
253   SetErrorCode(OK);
254   return aCopy;
255 }
256
257 //=============================================================================
258 /*!
259  *  TranslateDXDYDZCopy
260  */
261 //=============================================================================
262 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateDXDYDZCopy
263        (Handle(GEOM_Object) theObject, double theX, double theY,  double theZ)
264 {
265   SetErrorCode(KO);
266
267   if (theObject.IsNull()) return NULL;
268
269   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
270   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
271
272   //Add a new Copy object
273   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
274
275   //Add a translate function
276   Handle(GEOM_Function) aFunction =
277     aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_XYZ_COPY);
278
279   //Check if the function is set correctly
280   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
281
282   GEOMImpl_ITranslate aTI(aFunction);
283   aTI.SetDX(theX);
284   aTI.SetDY(theY);
285   aTI.SetDZ(theZ);
286   aTI.SetOriginal(aLastFunction);
287
288   //Compute the translation
289   try {
290     OCC_CATCH_SIGNALS;
291     if (!GetSolver()->ComputeFunction(aFunction)) {
292       SetErrorCode("Translation driver failed");
293       return NULL;
294     }
295   }
296   catch (Standard_Failure) {
297     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
298     SetErrorCode(aFail->GetMessageString());
299     return NULL;
300   }
301
302   //Make a Python command
303   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeTranslation("
304     << theObject << ", " << theX << ", " << theY << ", " << theZ << ")";
305
306   SetErrorCode(OK);
307   return aCopy;
308 }
309
310
311 //=============================================================================
312 /*!
313  *  TranslateVector
314  */
315 //=============================================================================
316 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateVector
317        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector)
318 {
319   SetErrorCode(KO);
320
321   if (theObject.IsNull() || theVector.IsNull()) return NULL;
322
323   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
324   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
325
326   // Get last functions of the arguments
327   Handle(GEOM_Function) aVF = theVector->GetLastFunction();
328
329   //Add a translate function
330   aFunction = theObject->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_VECTOR);
331
332   if (aFunction.IsNull()) return NULL;
333
334   //Check if the function is set correctly
335   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
336
337   GEOMImpl_ITranslate aTI (aFunction);
338   aTI.SetVector(aVF);
339   aTI.SetOriginal(aLastFunction);
340
341   //Compute the translation
342   try {
343     OCC_CATCH_SIGNALS;
344     if (!GetSolver()->ComputeFunction(aFunction)) {
345       SetErrorCode("Translation driver failed");
346       return NULL;
347     }
348   }
349   catch (Standard_Failure) {
350     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
351     SetErrorCode(aFail->GetMessageString());
352     return NULL;
353   }
354
355   //Make a Python command
356   GEOM::TPythonDump(aFunction) << "geompy.TranslateVector("
357                                << theObject << ", " << theVector << ")";
358
359   SetErrorCode(OK);
360   return theObject;
361 }
362 //=============================================================================
363 /*!
364  *  TranslateVectorCopy
365  */
366 //=============================================================================
367 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateVectorCopy
368        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector)
369 {
370   SetErrorCode(KO);
371
372   if (theObject.IsNull() || theVector.IsNull()) return NULL;
373
374   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
375   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
376
377   //Add a new Copy object
378   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
379
380   //Add a translate function
381   Handle(GEOM_Function) aFunction =
382     aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_VECTOR_COPY);
383
384   //Check if the function is set correctly
385   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
386
387   GEOMImpl_ITranslate aTI(aFunction);
388   aTI.SetVector(theVector->GetLastFunction());
389 //  aTI.SetShape(theObject->GetValue());
390   aTI.SetOriginal(aLastFunction);
391
392   //Compute the translation
393   try {
394     OCC_CATCH_SIGNALS;
395     if (!GetSolver()->ComputeFunction(aFunction)) {
396       SetErrorCode("Translation driver failed");
397       return NULL;
398     }
399   }
400   catch (Standard_Failure) {
401     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
402     SetErrorCode(aFail->GetMessageString());
403     return NULL;
404   }
405
406   //Make a Python command
407   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeTranslationVector("
408                                << theObject << ", " << theVector << ")";
409
410   SetErrorCode(OK);
411   return aCopy;
412 }
413
414 //=============================================================================
415 /*!
416  *  TranslateVectorDistance
417  */
418 //=============================================================================
419 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TranslateVectorDistance
420        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector, double theDistance, bool theCopy)
421 {
422   SetErrorCode(KO);
423
424   if (theObject.IsNull() || theVector.IsNull()) return NULL;
425
426   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
427   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
428
429   Handle(GEOM_Object) aCopy;   //Add a new Copy object
430   Handle(GEOM_Function) aFunction;
431
432   //Add a translate function
433   if (theCopy) {
434     aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
435     aFunction = aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_VECTOR_DISTANCE);
436   }
437   else {
438     aFunction = theObject->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_VECTOR_DISTANCE);
439   }
440   if (aFunction.IsNull()) return NULL;
441
442   //Check if the function is set correctly
443   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
444
445   GEOMImpl_ITranslate aTI(aFunction);
446   aTI.SetVector(theVector->GetLastFunction());
447   aTI.SetDistance(theDistance);
448 //  aTI.SetShape(theObject->GetValue());
449   aTI.SetOriginal(aLastFunction);
450
451   //Compute the translation
452   try {
453     OCC_CATCH_SIGNALS;
454     if (!GetSolver()->ComputeFunction(aFunction)) {
455       SetErrorCode("Translation driver failed");
456       return NULL;
457     }
458   }
459   catch (Standard_Failure) {
460     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
461     SetErrorCode(aFail->GetMessageString());
462     return NULL;
463   }
464
465   //Make a Python command
466   if (theCopy) {
467     GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeTranslationVectorDistance("
468                                  << theObject << ", " << theVector << ", " << theDistance << ")";
469     SetErrorCode(OK);
470     return aCopy;
471   }
472
473   GEOM::TPythonDump(aFunction) << "geompy.TranslateVectorDistance("
474                                << theObject << ", " << theVector << ", " << theDistance << ", " << theCopy << ")";
475   SetErrorCode(OK);
476   return theObject;
477 }
478
479 //=============================================================================
480 /*!
481  *  Translate1D
482  */
483 //=============================================================================
484 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Translate1D
485        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector,
486         double theStep, Standard_Integer theNbTimes)
487 {
488   SetErrorCode(KO);
489
490   if (theObject.IsNull()) return NULL;
491
492   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
493   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
494
495   //Add a new Copy object
496   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
497
498   //Add a translate function
499   Handle(GEOM_Function) aFunction =
500     aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_1D);
501
502   //Check if the function is set correctly
503   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
504
505   GEOMImpl_ITranslate aTI (aFunction);
506   aTI.SetOriginal(aLastFunction);
507   if (!theVector.IsNull())
508     aTI.SetVector(theVector->GetLastFunction());
509   aTI.SetStep1(theStep);
510   aTI.SetNbIter1(theNbTimes);
511
512   //Compute the translation
513   try {
514     OCC_CATCH_SIGNALS;
515     if (!GetSolver()->ComputeFunction(aFunction)) {
516       SetErrorCode("Translation driver failed");
517       return NULL;
518     }
519   }
520   catch (Standard_Failure) {
521     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
522     SetErrorCode(aFail->GetMessageString());
523     return NULL;
524   }
525
526   //Make a Python command
527   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeMultiTranslation1D("
528     << theObject << ", " << theVector << ", " << theStep << ", " << theNbTimes << ")";
529
530   SetErrorCode(OK);
531   return aCopy;
532 }
533
534 //=============================================================================
535 /*!
536  *  Translate2D
537  */
538 //=============================================================================
539 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Translate2D (Handle(GEOM_Object) theObject,
540                                                                 Handle(GEOM_Object) theVector,
541                                                                 double theStep1,
542                                                                 Standard_Integer theNbTimes1,
543                                                                 Handle(GEOM_Object) theVector2,
544                                                                 double theStep2,
545                                                                 Standard_Integer theNbTimes2)
546 {
547   SetErrorCode(KO);
548
549   if (theObject.IsNull()) return NULL;
550
551   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
552   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be moved
553
554   //Add a new Copy object
555   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
556
557   //Add a translate function
558   Handle(GEOM_Function) aFunction =
559     aCopy->AddFunction(GEOMImpl_TranslateDriver::GetID(), TRANSLATE_2D);
560
561   //Check if the function is set correctly
562   if (aFunction->GetDriverGUID() != GEOMImpl_TranslateDriver::GetID()) return NULL;
563
564   GEOMImpl_ITranslate aTI (aFunction);
565   aTI.SetOriginal(aLastFunction);
566   if (!theVector.IsNull())
567     aTI.SetVector(theVector->GetLastFunction());
568   aTI.SetStep1(theStep1);
569   aTI.SetNbIter1(theNbTimes1);
570   if (!theVector2.IsNull())
571     aTI.SetVector2(theVector2->GetLastFunction());
572   aTI.SetStep2(theStep2);
573   aTI.SetNbIter2(theNbTimes2);
574
575   //Compute the translation
576   try {
577     OCC_CATCH_SIGNALS;
578     if (!GetSolver()->ComputeFunction(aFunction)) {
579       SetErrorCode("Translation driver failed");
580       return NULL;
581     }
582   }
583   catch (Standard_Failure) {
584     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
585     SetErrorCode(aFail->GetMessageString());
586     return NULL;
587   }
588
589   //Make a Python command
590   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeMultiTranslation2D("
591     << theObject << ", " << theVector  << ", " << theStep1 << ", " << theNbTimes1
592       << ", " << theVector2 << ", " << theStep2 << ", " << theNbTimes2 << ")";
593
594   SetErrorCode(OK);
595   return aCopy;
596 }
597
598 //=============================================================================
599 /*!
600  *  TranslateShape1D
601  */
602 //=============================================================================
603 /*
604 TopoDS_Shape GEOMImpl_ITransformOperations::TranslateShape1D (const TopoDS_Shape&  theShape,
605                                                               GEOMImpl_ITranslate* theTI)
606 {
607   TopoDS_Shape aRes;
608
609   // Vector
610   Handle(GEOM_Function) aVector = theTI->GetVector();
611   if (aVector.IsNull()) {
612     StdFail_NotDone::Raise("Invalid object is given for vector argument");
613   }
614   TopoDS_Shape aV = aVector->GetValue();
615   if (aV.IsNull() || aV.ShapeType() != TopAbs_EDGE) {
616     StdFail_NotDone::Raise("Invalid object is given for vector argument");
617   }
618   TopoDS_Edge anEdge = TopoDS::Edge(aV);
619
620   gp_Pnt aP1 = BRep_Tool::Pnt(TopExp::FirstVertex(anEdge));
621   gp_Pnt aP2 = BRep_Tool::Pnt(TopExp::LastVertex(anEdge));
622   if (aP1.Distance(aP2) < gp::Resolution()) {
623     StdFail_NotDone::Raise("Invalid object is given for vector argument");
624   }
625
626   // Step and Nb.times
627   Standard_Real step = theTI->GetStep1();
628   Standard_Integer nbtimes = theTI->GetNbIter1();
629
630   // Make multi-translation
631   gp_Trsf aTrsf;
632   gp_Vec aVec;
633   TopoDS_Compound aCompound;
634   BRep_Builder B;
635   B.MakeCompound(aCompound);
636
637   gp_Vec Vec (aP1, aP2);
638   Vec.Normalize();
639
640   TopLoc_Location aLocOrig = theShape.Location();
641   gp_Trsf aTrsfOrig = aLocOrig.Transformation();
642
643   for (int i = 0; i < nbtimes; i++) {
644     aVec = Vec * (i * step);
645     aTrsf.SetTranslation(aVec);
646     //NPAL18620: performance problem: multiple locations are accumulated
647     //           in shape and need a great time to process
648     //BRepBuilderAPI_Transform aTransformation(theShape, aTrsf, Standard_False);
649     //B.Add(aCompound, aTransformation.Shape());
650     TopLoc_Location aLocRes (aTrsf * aTrsfOrig);
651     B.Add(aCompound, theShape.Located(aLocRes));
652   }
653   aRes = aCompound;
654
655   return aRes;
656 }
657 */
658
659 //=============================================================================
660 /*!
661  *  TranslateShape2D
662  */
663 //=============================================================================
664 /*
665 TopoDS_Shape GEOMImpl_ITransformOperations::TranslateShape2D (const TopoDS_Shape&  theShape,
666                                                               GEOMImpl_ITranslate* theTI)
667 {
668   TopoDS_Shape aRes;
669
670   // Vectors
671   Handle(GEOM_Function) aVector1 = theTI->GetVector();
672   Handle(GEOM_Function) aVector2 = theTI->GetVector2();
673
674   if (aVector1.IsNull() || aVector2.IsNull()) {
675     StdFail_NotDone::Raise("Invalid object is given for vector argument");
676   }
677
678   TopoDS_Shape aV1 = aVector1->GetValue();
679   TopoDS_Shape aV2 = aVector2->GetValue();
680
681   if (aV1.IsNull() || aV1.ShapeType() != TopAbs_EDGE ||
682       aV2.IsNull() || aV2.ShapeType() != TopAbs_EDGE) {
683     StdFail_NotDone::Raise("Invalid object is given for vector argument");
684   }
685
686   TopoDS_Edge anEdge1 = TopoDS::Edge(aV1);
687   TopoDS_Edge anEdge2 = TopoDS::Edge(aV2);
688
689   gp_Pnt aP11 = BRep_Tool::Pnt(TopExp::FirstVertex(anEdge1));
690   gp_Pnt aP12 = BRep_Tool::Pnt(TopExp::LastVertex(anEdge1));
691   gp_Pnt aP21 = BRep_Tool::Pnt(TopExp::FirstVertex(anEdge2));
692   gp_Pnt aP22 = BRep_Tool::Pnt(TopExp::LastVertex(anEdge2));
693
694   if (aP11.Distance(aP12) < gp::Resolution() ||
695       aP21.Distance(aP22) < gp::Resolution()) {
696     StdFail_NotDone::Raise("Invalid object is given for vector argument");
697   }
698
699   gp_Vec Vec1 (aP11, aP12);
700   gp_Vec Vec2 (aP21, aP22);
701
702   Vec1.Normalize();
703   Vec2.Normalize();
704
705   // Step and Nb.times
706   Standard_Real step1 = theTI->GetStep1(), step2 = theTI->GetStep2();
707   Standard_Integer nbtimes1 = theTI->GetNbIter1(), nbtimes2 = theTI->GetNbIter2();
708
709   // Make multi-translation
710   gp_Trsf aTrsf;
711   gp_Vec aVec;
712   Standard_Real DX, DY, DZ;
713   TopoDS_Compound aCompound;
714   BRep_Builder B;
715   B.MakeCompound(aCompound);
716
717   TopLoc_Location aLocOrig = theShape.Location();
718   gp_Trsf aTrsfOrig = aLocOrig.Transformation();
719
720   for (int i = 0; i < nbtimes1; i++) {
721     for (int j = 0; j < nbtimes2; j++) {
722       DX = i * step1 * Vec1.X() + j * step2 * Vec2.X();
723       DY = i * step1 * Vec1.Y() + j * step2 * Vec2.Y();
724       DZ = i * step1 * Vec1.Z() + j * step2 * Vec2.Z();
725       aVec.SetCoord(DX, DY, DZ);
726       aTrsf.SetTranslation(aVec);
727       //NPAL18620: performance problem: multiple locations are accumulated
728       //           in shape and need a great time to process
729       //BRepBuilderAPI_Transform aBRepTransformation(theShape, aTrsf, Standard_False);
730       //B.Add(aCompound, aBRepTransformation.Shape());
731       TopLoc_Location aLocRes (aTrsf * aTrsfOrig);
732       B.Add(aCompound, theShape.Located(aLocRes));
733     }
734   }
735   aRes = aCompound;
736
737   return aRes;
738 }
739 */
740
741 //=============================================================================
742 /*!
743  *  MirrorPlane
744  */
745 //=============================================================================
746 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorPlane
747        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePlane)
748 {
749   SetErrorCode(KO);
750
751   if (theObject.IsNull() || thePlane.IsNull()) return NULL;
752
753   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
754   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be mirrored
755
756   // Get last functions of the arguments
757   Handle(GEOM_Function) aPF = thePlane->GetLastFunction();
758
759   //Add a mirror function
760   Handle(GEOM_Function) aFunction =
761     theObject->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_PLANE);
762   if (aFunction.IsNull()) return NULL;
763
764   //Check if the function is set correctly
765   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
766
767   GEOMImpl_IMirror aTI (aFunction);
768   aTI.SetPlane(aPF);
769   aTI.SetOriginal(aLastFunction);
770
771   //Compute the mirror
772   try {
773     OCC_CATCH_SIGNALS;
774     if (!GetSolver()->ComputeFunction(aFunction)) {
775       SetErrorCode("Mirror driver failed");
776       return NULL;
777     }
778   }
779   catch (Standard_Failure) {
780     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
781     SetErrorCode(aFail->GetMessageString());
782     return NULL;
783   }
784
785   //Make a Python command
786   GEOM::TPythonDump(aFunction) << "geompy.MirrorByPlane("
787                                << theObject << ", " << thePlane << ")";
788
789   SetErrorCode(OK);
790   return theObject;
791 }
792
793 //=============================================================================
794 /*!
795  *  MirrorPlaneCopy
796  */
797 //=============================================================================
798 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorPlaneCopy
799        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePlane)
800 {
801   SetErrorCode(KO);
802
803   if (theObject.IsNull() || thePlane.IsNull()) return NULL;
804
805   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
806   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be mirrored
807
808   //Add a new Copy object
809   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
810
811   //Add a mirror function
812   Handle(GEOM_Function) aFunction =
813     aCopy->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_PLANE_COPY);
814
815   //Check if the function is set correctly
816   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
817
818   GEOMImpl_IMirror aTI (aFunction);
819   aTI.SetPlane(thePlane->GetLastFunction());
820   aTI.SetOriginal(aLastFunction);
821
822   //Compute the mirror
823   try {
824     OCC_CATCH_SIGNALS;
825     if (!GetSolver()->ComputeFunction(aFunction)) {
826       SetErrorCode("Mirror driver failed");
827       return NULL;
828     }
829   }
830   catch (Standard_Failure) {
831     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
832     SetErrorCode(aFail->GetMessageString());
833     return NULL;
834   }
835
836   //Make a Python command
837   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeMirrorByPlane("
838                                << theObject << ", " << thePlane << ")";
839
840   SetErrorCode(OK);
841   return aCopy;
842 }
843
844 //=============================================================================
845 /*!
846  *  MirrorPoint
847  */
848 //=============================================================================
849 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorPoint
850        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint)
851 {
852   SetErrorCode(KO);
853
854   if (theObject.IsNull() || thePoint.IsNull()) return NULL;
855
856   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
857   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be mirrored
858
859   // Get last functions of the arguments
860   Handle(GEOM_Function) aPF = thePoint->GetLastFunction();
861
862   //Add a mirror function
863   Handle(GEOM_Function) aFunction =
864     theObject->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_POINT);
865   if (aFunction.IsNull()) return NULL;
866
867   //Check if the function is set correctly
868   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
869
870   GEOMImpl_IMirror aTI (aFunction);
871   aTI.SetPoint(aPF);
872   aTI.SetOriginal(aLastFunction);
873
874   //Compute the mirror
875   try {
876     OCC_CATCH_SIGNALS;
877     if (!GetSolver()->ComputeFunction(aFunction)) {
878       SetErrorCode("Mirror driver failed");
879       return NULL;
880     }
881   }
882   catch (Standard_Failure) {
883     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
884     SetErrorCode(aFail->GetMessageString());
885     return NULL;
886   }
887
888   //Make a Python command
889   GEOM::TPythonDump(aFunction) << "geompy.MirrorByPoint("
890                                << theObject << ", " << thePoint << ")";
891
892   SetErrorCode(OK);
893   return NULL;
894 }
895
896 //=============================================================================
897 /*!
898  *  MirrorPointCopy
899  */
900 //=============================================================================
901 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorPointCopy
902        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint)
903 {
904   SetErrorCode(KO);
905
906   if (theObject.IsNull() || thePoint.IsNull()) return NULL;
907
908   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
909   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be mirrored
910
911   //Add a new Copy object
912   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
913
914   //Add a mirror function
915   Handle(GEOM_Function) aFunction =
916     aCopy->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_POINT_COPY);
917
918   //Check if the function is set correctly
919   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
920
921   GEOMImpl_IMirror aTI (aFunction);
922   aTI.SetPoint(thePoint->GetLastFunction());
923   aTI.SetOriginal(aLastFunction);
924
925   //Compute the mirror
926   try {
927     OCC_CATCH_SIGNALS;
928     if (!GetSolver()->ComputeFunction(aFunction)) {
929       SetErrorCode("Mirror driver failed");
930       return NULL;
931     }
932   }
933   catch (Standard_Failure) {
934     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
935     SetErrorCode(aFail->GetMessageString());
936     return NULL;
937   }
938
939   //Make a Python command
940   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeMirrorByPoint("
941                                << theObject << ", " << thePoint << ")";
942
943   SetErrorCode(OK);
944   return aCopy;
945 }
946
947 //=============================================================================
948 /*!
949  *  MirrorAxis
950  */
951 //=============================================================================
952 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorAxis
953        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis)
954 {
955   SetErrorCode(KO);
956
957   if (theObject.IsNull() || theAxis.IsNull()) return NULL;
958
959   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
960   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be mirrored
961
962   // Get last functions of the arguments
963   Handle(GEOM_Function) anAF = theAxis->GetLastFunction();
964
965   //Add a mirror function
966   Handle(GEOM_Function) aFunction =
967     theObject->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_AXIS);
968   if (aFunction.IsNull()) return NULL;
969
970   //Check if the function is set correctly
971   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
972
973   GEOMImpl_IMirror aTI (aFunction);
974   aTI.SetAxis(anAF);
975   aTI.SetOriginal(aLastFunction);
976
977   //Compute the mirror
978   try {
979     OCC_CATCH_SIGNALS;
980     if (!GetSolver()->ComputeFunction(aFunction)) {
981       SetErrorCode("Mirror driver failed");
982       return NULL;
983     }
984   }
985   catch (Standard_Failure) {
986     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
987     SetErrorCode(aFail->GetMessageString());
988     return NULL;
989   }
990
991   //Make a Python command
992   GEOM::TPythonDump(aFunction) << "geompy.MirrorByAxis("
993                                << theObject << ", " << theAxis << ")";
994
995   SetErrorCode(OK);
996   return NULL;
997 }
998
999 //=============================================================================
1000 /*!
1001  *  MirrorAxisCopy
1002  */
1003 //=============================================================================
1004 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MirrorAxisCopy
1005        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis)
1006 {
1007   SetErrorCode(KO);
1008
1009   if (theObject.IsNull() || theAxis.IsNull()) return NULL;
1010
1011   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
1012   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be mirrored
1013
1014   //Add a new Copy object
1015   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
1016
1017   //Add a mirror function
1018   Handle(GEOM_Function) aFunction =
1019     aCopy->AddFunction(GEOMImpl_MirrorDriver::GetID(), MIRROR_AXIS_COPY);
1020
1021   //Check if the function is set correctly
1022   if (aFunction->GetDriverGUID() != GEOMImpl_MirrorDriver::GetID()) return NULL;
1023
1024   GEOMImpl_IMirror aTI (aFunction);
1025   aTI.SetAxis(theAxis->GetLastFunction());
1026   aTI.SetOriginal(aLastFunction);
1027
1028   //Compute the mirror
1029   try {
1030     OCC_CATCH_SIGNALS;
1031     if (!GetSolver()->ComputeFunction(aFunction)) {
1032       SetErrorCode("Mirror driver failed");
1033       return NULL;
1034     }
1035   }
1036   catch (Standard_Failure) {
1037     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1038     SetErrorCode(aFail->GetMessageString());
1039     return NULL;
1040   }
1041
1042   //Make a Python command
1043   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeMirrorByAxis("
1044                                << theObject << ", " << theAxis << ")";
1045
1046   SetErrorCode(OK);
1047   return aCopy;
1048 }
1049
1050
1051 //=============================================================================
1052 /*!
1053  *  OffsetShape
1054  */
1055 //=============================================================================
1056 Handle(GEOM_Object) GEOMImpl_ITransformOperations::OffsetShape
1057                               (Handle(GEOM_Object) theObject, double theOffset)
1058 {
1059   SetErrorCode(KO);
1060
1061   if (theObject.IsNull()) return NULL;
1062
1063   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1064   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be offset
1065
1066   //Add a new Offset function
1067   Handle(GEOM_Function) aFunction =
1068     theObject->AddFunction(GEOMImpl_OffsetDriver::GetID(), OFFSET_SHAPE);
1069   if (aFunction.IsNull()) return NULL;
1070
1071   //Check if the function is set correctly
1072   if (aFunction->GetDriverGUID() != GEOMImpl_OffsetDriver::GetID()) return NULL;
1073
1074   GEOMImpl_IOffset aTI (aFunction);
1075   aTI.SetShape(anOriginal);
1076   aTI.SetValue(theOffset);
1077
1078   //Compute the offset
1079   try {
1080     OCC_CATCH_SIGNALS;
1081     if (!GetSolver()->ComputeFunction(aFunction)) {
1082       SetErrorCode("Offset driver failed");
1083       return NULL;
1084     }
1085   }
1086   catch (Standard_Failure) {
1087     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1088     SetErrorCode(aFail->GetMessageString());
1089     return NULL;
1090   }
1091
1092   //Make a Python command
1093   GEOM::TPythonDump(aFunction) << "geompy.Offset("
1094                                << theObject << ", " << theOffset << ")";
1095
1096   SetErrorCode(OK);
1097   return theObject;
1098 }
1099
1100 //=============================================================================
1101 /*!
1102  *  OffsetShapeCopy
1103  */
1104 //=============================================================================
1105 Handle(GEOM_Object) GEOMImpl_ITransformOperations::OffsetShapeCopy
1106                               (Handle(GEOM_Object) theObject, double theOffset)
1107 {
1108   SetErrorCode(KO);
1109
1110   if (theObject.IsNull()) return NULL;
1111
1112   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1113   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be offset
1114
1115   //Add a new Copy object
1116   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
1117
1118   //Add a new Offset function
1119   Handle(GEOM_Function) aFunction =
1120     aCopy->AddFunction(GEOMImpl_OffsetDriver::GetID(), OFFSET_SHAPE_COPY);
1121   if (aFunction.IsNull()) return NULL;
1122
1123   //Check if the function is set correctly
1124   if (aFunction->GetDriverGUID() != GEOMImpl_OffsetDriver::GetID()) return NULL;
1125
1126   GEOMImpl_IOffset aTI (aFunction);
1127   aTI.SetShape(anOriginal);
1128   aTI.SetValue(theOffset);
1129
1130   //Compute the offset
1131   try {
1132     OCC_CATCH_SIGNALS;
1133     if (!GetSolver()->ComputeFunction(aFunction)) {
1134       SetErrorCode("Offset driver failed");
1135       return NULL;
1136     }
1137   }
1138   catch (Standard_Failure) {
1139     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1140     SetErrorCode(aFail->GetMessageString());
1141     return NULL;
1142   }
1143
1144   //Make a Python command
1145   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeOffset("
1146                                << theObject << ", " << theOffset << ")";
1147
1148   SetErrorCode(OK);
1149   return aCopy;
1150 }
1151
1152
1153 //=============================================================================
1154 /*!
1155  *  ProjectShapeCopy
1156  */
1157 //=============================================================================
1158 Handle(GEOM_Object)
1159 GEOMImpl_ITransformOperations::ProjectShapeCopy (Handle(GEOM_Object) theSource,
1160                                                  Handle(GEOM_Object) theTarget)
1161 {
1162   SetErrorCode(KO);
1163
1164   if (theSource.IsNull() || theTarget.IsNull()) return NULL;
1165
1166   Handle(GEOM_Function) aLastFunction = theSource->GetLastFunction();
1167   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be projected
1168
1169   Handle(GEOM_Object) aCopy;
1170
1171   TopoDS_Shape aTarget = theTarget->GetValue();
1172   if ( aTarget.IsNull() ) return NULL;
1173   if ( aTarget.ShapeType() == TopAbs_EDGE ||
1174        aTarget.ShapeType() == TopAbs_WIRE )
1175   {
1176     // a TPythonDump prevents dumping ProjectPointOnWire(),
1177     // dump of MakeProjection() is done at the end of this function
1178     GEOM::TPythonDump preventDump(aLastFunction, /*append=*/true);
1179     Standard_Integer dummy;
1180     ProjectPointOnWire( theSource, theTarget, aCopy, dummy );
1181     if ( aCopy.IsNull() || !IsDone() )
1182       return NULL;
1183   }
1184   else
1185   {
1186     //Add a new Projection object
1187     aCopy = GetEngine()->AddObject(GetDocID(), GEOM_PROJECTION);
1188
1189     //Add a Projection function
1190     Handle(GEOM_Function) aFunction =
1191       aCopy->AddFunction(GEOMImpl_ProjectionDriver::GetID(), PROJECTION_COPY);
1192
1193     //Check if the function is set correctly
1194     if (aFunction->GetDriverGUID() != GEOMImpl_ProjectionDriver::GetID()) return NULL;
1195
1196     GEOMImpl_IMirror aTI (aFunction);
1197     aTI.SetPlane(theTarget->GetLastFunction());
1198     aTI.SetOriginal(aLastFunction);
1199
1200     //Compute the Projection
1201     try {
1202       OCC_CATCH_SIGNALS;
1203       if (!GetSolver()->ComputeFunction(aFunction)) {
1204         SetErrorCode("Projection driver failed");
1205         return NULL;
1206       }
1207     }
1208     catch (Standard_Failure) {
1209       Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1210       SetErrorCode(aFail->GetMessageString());
1211       return NULL;
1212     }
1213   }
1214
1215   //Make a Python command
1216   Handle(GEOM_Function) aFunction = aCopy->GetLastFunction();
1217   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeProjection("
1218                                << theSource << ", " << theTarget << ")";
1219
1220   SetErrorCode(OK);
1221   return aCopy;
1222 }
1223
1224 //=============================================================================
1225 /*!
1226  *  ProjectPointOnWire
1227  */
1228 //=============================================================================
1229 Standard_Real GEOMImpl_ITransformOperations::ProjectPointOnWire
1230                                     (Handle(GEOM_Object) thePoint,
1231                                      Handle(GEOM_Object) theWire,
1232                                      Handle(GEOM_Object) &thePointOnEdge,
1233                                      Standard_Integer    &theEdgeInWireIndex)
1234 {
1235   Standard_Real aResult = -1.;
1236
1237   SetErrorCode(KO);
1238
1239   if (thePoint.IsNull() || theWire.IsNull()) {
1240     return aResult;
1241   }
1242
1243   Handle(GEOM_Function) aLastFunction = thePoint->GetLastFunction();
1244
1245   if (aLastFunction.IsNull()) {
1246     //There is no function which creates an object to be projected
1247     return aResult;
1248   }
1249
1250   //Add a new Projection object
1251   thePointOnEdge = GetEngine()->AddObject(GetDocID(), GEOM_PROJECTION);
1252
1253   //Add a Projection function
1254   Handle(GEOM_Function) aFunction = thePointOnEdge->AddFunction
1255     (GEOMImpl_ProjectionDriver::GetID(), PROJECTION_ON_WIRE);
1256
1257   //Check if the function is set correctly
1258   if (aFunction->GetDriverGUID() != GEOMImpl_ProjectionDriver::GetID()) {
1259     return aResult;
1260   }
1261
1262   GEOMImpl_IProjection aProj (aFunction);
1263   aProj.SetPoint(aLastFunction);
1264   aProj.SetShape(theWire->GetLastFunction());
1265
1266   //Compute the Projection
1267   try {
1268     OCC_CATCH_SIGNALS;
1269     if (!GetSolver()->ComputeFunction(aFunction)) {
1270       SetErrorCode("Projection driver failed");
1271       return aResult;
1272     }
1273   }
1274   catch (Standard_Failure) {
1275     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1276     SetErrorCode(aFail->GetMessageString());
1277     return aResult;
1278   }
1279
1280   aResult            = aProj.GetU();
1281   theEdgeInWireIndex = aProj.GetIndex();
1282
1283
1284   //Make a Python command
1285   GEOM::TPythonDump(aFunction) << "(u, " << thePointOnEdge
1286     << ", EdgeInWireIndex) = geompy.MakeProjectionOnWire(" << thePoint
1287     << ", " << theWire << ")";
1288
1289   SetErrorCode(OK);
1290
1291   return aResult;
1292 }
1293
1294 //=============================================================================
1295 /*!
1296  *  ScaleShape
1297  */
1298 //=============================================================================
1299 Handle(GEOM_Object) GEOMImpl_ITransformOperations::ScaleShape
1300        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint, double theFactor)
1301 {
1302   SetErrorCode(KO);
1303
1304   if (theObject.IsNull()) return NULL;
1305
1306   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1307   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be scaled
1308
1309   //Add a scale function
1310   Handle(GEOM_Function) aFunction =
1311     theObject->AddFunction(GEOMImpl_ScaleDriver::GetID(), SCALE_SHAPE);
1312   if (aFunction.IsNull()) return NULL;
1313
1314   //Check if the function is set correctly
1315   if (aFunction->GetDriverGUID() != GEOMImpl_ScaleDriver::GetID()) return NULL;
1316
1317   // Set arguments
1318   GEOMImpl_IScale aTI (aFunction);
1319   aTI.SetShape(anOriginal);
1320   aTI.SetFactor(theFactor);
1321
1322   // Set point argument
1323   if (!thePoint.IsNull()) {
1324     Handle(GEOM_Function) aPF = thePoint->GetLastFunction();
1325     aTI.SetPoint(aPF);
1326   }
1327
1328   //Compute the scale
1329   try {
1330     OCC_CATCH_SIGNALS;
1331     if (!GetSolver()->ComputeFunction(aFunction)) {
1332       SetErrorCode("Scale driver failed");
1333       return NULL;
1334     }
1335   }
1336   catch (Standard_Failure) {
1337     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1338     SetErrorCode(aFail->GetMessageString());
1339     return NULL;
1340   }
1341
1342   //Make a Python command
1343   GEOM::TPythonDump(aFunction) << "geompy.Scale("
1344     << theObject << ", " << thePoint << ", " << theFactor << ")";
1345
1346   SetErrorCode(OK);
1347   return theObject;
1348 }
1349
1350 //=============================================================================
1351 /*!
1352  *  ScaleShapeCopy
1353  */
1354 //=============================================================================
1355 Handle(GEOM_Object) GEOMImpl_ITransformOperations::ScaleShapeCopy
1356        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePoint, double theFactor)
1357 {
1358   SetErrorCode(KO);
1359
1360   if (theObject.IsNull()) return NULL;
1361
1362   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1363   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be scaled
1364
1365   //Add a new Copy object
1366   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
1367
1368   //Add a scale function
1369   Handle(GEOM_Function) aFunction =
1370     aCopy->AddFunction(GEOMImpl_ScaleDriver::GetID(), SCALE_SHAPE_COPY);
1371   if (aFunction.IsNull()) return NULL;
1372
1373   //Check if the function is set correctly
1374   if (aFunction->GetDriverGUID() != GEOMImpl_ScaleDriver::GetID()) return NULL;
1375
1376   // Set arguments
1377   GEOMImpl_IScale aTI (aFunction);
1378   aTI.SetShape(anOriginal);
1379   aTI.SetFactor(theFactor);
1380
1381   // Set point argument
1382   if (!thePoint.IsNull()) {
1383     Handle(GEOM_Function) aPF = thePoint->GetLastFunction();
1384     aTI.SetPoint(aPF);
1385   }
1386
1387   //Compute the scale
1388   try {
1389     OCC_CATCH_SIGNALS;
1390     if (!GetSolver()->ComputeFunction(aFunction)) {
1391       SetErrorCode("Scale driver failed");
1392       return NULL;
1393     }
1394   }
1395   catch (Standard_Failure) {
1396     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1397     SetErrorCode(aFail->GetMessageString());
1398     return NULL;
1399   }
1400
1401   //Make a Python command
1402   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeScaleTransform("
1403     << theObject << ", " << thePoint << ", " << theFactor << ")";
1404
1405   SetErrorCode(OK);
1406   return aCopy;
1407 }
1408
1409 //=============================================================================
1410 /*!
1411  *  ScaleShapeAlongAxes
1412  */
1413 //=============================================================================
1414 Handle(GEOM_Object) GEOMImpl_ITransformOperations::ScaleShapeAlongAxes (Handle(GEOM_Object) theObject,
1415                                                                         Handle(GEOM_Object) thePoint,
1416                                                                         double theFactorX,
1417                                                                         double theFactorY,
1418                                                                         double theFactorZ,
1419                                                                         bool   doCopy)
1420 {
1421   SetErrorCode(KO);
1422
1423   if (theObject.IsNull()) return NULL;
1424
1425   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1426   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be scaled
1427
1428   //Add a scale function
1429   Handle(GEOM_Object) aCopy;   //Add a new Copy object
1430   Handle(GEOM_Function) aFunction;
1431   if (doCopy) {
1432     aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1433     aFunction = aCopy->AddFunction(GEOMImpl_ScaleDriver::GetID(), SCALE_SHAPE_AXES_COPY);
1434   }
1435   else {
1436     aFunction = theObject->AddFunction(GEOMImpl_ScaleDriver::GetID(), SCALE_SHAPE_AXES);
1437   }
1438   if (aFunction.IsNull()) return NULL;
1439
1440   //Check if the function is set correctly
1441   if (aFunction->GetDriverGUID() != GEOMImpl_ScaleDriver::GetID()) return NULL;
1442
1443   // Set arguments
1444   GEOMImpl_IScale aTI (aFunction);
1445   aTI.SetShape(anOriginal);
1446   aTI.SetFactorX(theFactorX);
1447   aTI.SetFactorY(theFactorY);
1448   aTI.SetFactorZ(theFactorZ);
1449
1450   // Set point (optional argument)
1451   if (!thePoint.IsNull()) {
1452     Handle(GEOM_Function) aPF = thePoint->GetLastFunction();
1453     aTI.SetPoint(aPF);
1454   }
1455
1456   //Compute the scale
1457   try {
1458     OCC_CATCH_SIGNALS;
1459     if (!GetSolver()->ComputeFunction(aFunction)) {
1460       SetErrorCode("Scale driver failed");
1461       return NULL;
1462     }
1463   }
1464   catch (Standard_Failure) {
1465     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1466     SetErrorCode(aFail->GetMessageString());
1467     return NULL;
1468   }
1469
1470   SetErrorCode(OK);
1471
1472   //Make a Python command
1473   if (doCopy) {
1474     GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeScaleAlongAxes("
1475                                  << theObject << ", " << thePoint << ", "
1476                                  << theFactorX << ", " << theFactorY << ", " << theFactorZ << ")";
1477     return aCopy;
1478   }
1479
1480   GEOM::TPythonDump(aFunction) << "geompy.ScaleAlongAxes("
1481                                << theObject << ", " << thePoint << ", "
1482                                << theFactorX << ", " << theFactorY << ", " << theFactorZ << ")";
1483   return theObject;
1484 }
1485
1486 //=============================================================================
1487 /*!
1488  *  PositionShape
1489  */
1490 //=============================================================================
1491 Handle(GEOM_Object) GEOMImpl_ITransformOperations::PositionShape
1492         (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theStartLCS, Handle(GEOM_Object) theEndLCS)
1493 {
1494   SetErrorCode(KO);
1495
1496   if (theObject.IsNull() || theEndLCS.IsNull()) return NULL;
1497
1498   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1499   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be set in position
1500
1501   //Add a Position function
1502   Standard_Integer aType = POSITION_SHAPE;
1503   if (theStartLCS.IsNull()) aType = POSITION_SHAPE_FROM_GLOBAL;
1504
1505   Handle(GEOM_Function) aFunction =
1506     theObject->AddFunction(GEOMImpl_PositionDriver::GetID(), aType);
1507   if (aFunction.IsNull()) return NULL;
1508
1509   //Check if the function is set correctly
1510   if (aFunction->GetDriverGUID() != GEOMImpl_PositionDriver::GetID()) return NULL;
1511
1512   //Set operation arguments
1513   GEOMImpl_IPosition aTI (aFunction);
1514   aTI.SetShape(anOriginal);
1515   aTI.SetEndLCS(theEndLCS->GetLastFunction());
1516   if (!theStartLCS.IsNull())
1517     aTI.SetStartLCS(theObject == theStartLCS ? anOriginal : theStartLCS->GetLastFunction());
1518
1519   //Compute the Position
1520   try {
1521     OCC_CATCH_SIGNALS;
1522     if (!GetSolver()->ComputeFunction(aFunction)) {
1523       SetErrorCode("Position driver failed");
1524       return NULL;
1525     }
1526   }
1527   catch (Standard_Failure) {
1528     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1529     SetErrorCode(aFail->GetMessageString());
1530     return NULL;
1531   }
1532
1533   //Make a Python command
1534   GEOM::TPythonDump(aFunction) << "geompy.Position("
1535     << theObject << ", " << theStartLCS << ", " << theEndLCS << ")";
1536
1537   SetErrorCode(OK);
1538   return theObject;
1539 }
1540
1541 //=============================================================================
1542 /*!
1543  *  PositionShapeCopy
1544  */
1545 //=============================================================================
1546 Handle(GEOM_Object) GEOMImpl_ITransformOperations::PositionShapeCopy
1547        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theStartLCS, Handle(GEOM_Object) theEndLCS)
1548 {
1549   SetErrorCode(KO);
1550
1551   if (theObject.IsNull() || theEndLCS.IsNull()) return NULL;
1552
1553   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1554   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be set in position
1555
1556   //Add a new Copy object
1557   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
1558
1559   //Add a position function
1560   Standard_Integer aType = POSITION_SHAPE_COPY;
1561   if (theStartLCS.IsNull()) aType = POSITION_SHAPE_FROM_GLOBAL_COPY;
1562
1563   Handle(GEOM_Function) aFunction =
1564     aCopy->AddFunction(GEOMImpl_PositionDriver::GetID(), aType);
1565   if (aFunction.IsNull()) return NULL;
1566
1567   //Check if the function is set correctly
1568   if (aFunction->GetDriverGUID() != GEOMImpl_PositionDriver::GetID()) return NULL;
1569
1570   GEOMImpl_IPosition aTI (aFunction);
1571   aTI.SetShape(anOriginal);
1572   aTI.SetEndLCS(theEndLCS->GetLastFunction());
1573   if (!theStartLCS.IsNull())
1574     aTI.SetStartLCS(theStartLCS->GetLastFunction());
1575
1576   //Compute the position
1577   try {
1578     OCC_CATCH_SIGNALS;
1579     if (!GetSolver()->ComputeFunction(aFunction)) {
1580       SetErrorCode("Position driver failed");
1581       return NULL;
1582     }
1583   }
1584   catch (Standard_Failure) {
1585     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1586     SetErrorCode(aFail->GetMessageString());
1587     return NULL;
1588   }
1589
1590   //Make a Python command
1591   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakePosition("
1592     << theObject << ", " << theStartLCS << ", " << theEndLCS << ")";
1593
1594   SetErrorCode(OK);
1595   return aCopy;
1596 }
1597
1598 //=============================================================================
1599 /*!
1600  *  PositionAlongPath
1601  */
1602 //=============================================================================
1603 Handle(GEOM_Object) GEOMImpl_ITransformOperations::PositionAlongPath
1604        (Handle(GEOM_Object) theObject, Handle(GEOM_Object) thePath,
1605         double theDistance, bool theCopy, bool theReverse)
1606 {
1607   SetErrorCode(KO);
1608
1609   if (theObject.IsNull() || thePath.IsNull()) return NULL;
1610
1611   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
1612   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be set in position
1613
1614   //Add a position function
1615   Handle(GEOM_Function) aFunction;
1616   Handle(GEOM_Object) aCopy;
1617
1618   if (theCopy) {
1619     aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1620     aFunction = aCopy->AddFunction(GEOMImpl_PositionDriver::GetID(), POSITION_ALONG_PATH);
1621   }
1622   else
1623     aFunction = theObject->AddFunction(GEOMImpl_PositionDriver::GetID(), POSITION_ALONG_PATH);
1624
1625   if (aFunction.IsNull()) return NULL;
1626
1627   //Check if the function is set correctly
1628   if (aFunction->GetDriverGUID() != GEOMImpl_PositionDriver::GetID()) return NULL;
1629
1630   GEOMImpl_IPosition aTI (aFunction);
1631   aTI.SetShape(anOriginal);
1632   aTI.SetPath(thePath->GetLastFunction());
1633   aTI.SetDistance(theDistance);
1634   aTI.SetReverse(theReverse);
1635
1636   //Compute the position
1637   try {
1638     OCC_CATCH_SIGNALS;
1639     if (!GetSolver()->ComputeFunction(aFunction)) {
1640       SetErrorCode("Position driver failed");
1641       return NULL;
1642     }
1643   }
1644   catch (Standard_Failure) {
1645     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1646     SetErrorCode(aFail->GetMessageString());
1647     return NULL;
1648   }
1649
1650   //Make a Python command
1651   if (theCopy) {
1652     GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakePositionAlongPath("
1653                                  << theObject << ", " << thePath << ", " << theDistance << ", " << theCopy << ", " << theReverse << ")";
1654     SetErrorCode(OK);
1655     return aCopy;
1656   }
1657
1658   GEOM::TPythonDump(aFunction) << "geompy.PositionAlongPath("
1659     << theObject << ", " << thePath << ", " << theDistance << ", " << theCopy << ", " << theReverse << ")";
1660
1661   SetErrorCode(OK);
1662   return theObject;
1663 }
1664
1665 //=============================================================================
1666 /*!
1667  *  Rotate
1668  */
1669 //=============================================================================
1670 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Rotate (Handle(GEOM_Object) theObject,
1671                                                            Handle(GEOM_Object) theAxis,
1672                                                            double theAngle)
1673 {
1674   SetErrorCode(KO);
1675
1676   if (theObject.IsNull() || theAxis.IsNull()) return NULL;
1677
1678   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1679   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1680
1681   // Get last functions of the arguments
1682   Handle(GEOM_Function) anAF = theAxis->GetLastFunction();
1683
1684   //Add a rotate function
1685   aFunction = theObject->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE);
1686
1687   if (aFunction.IsNull()) return NULL;
1688
1689   //Check if the function is set correctly
1690   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1691
1692   GEOMImpl_IRotate aRI(aFunction);
1693   aRI.SetAxis(anAF);
1694   aRI.SetOriginal(aLastFunction);
1695   aRI.SetAngle(theAngle);
1696
1697   //Compute the translation
1698   try {
1699     OCC_CATCH_SIGNALS;
1700     if (!GetSolver()->ComputeFunction(aFunction)) {
1701       SetErrorCode("Rotate driver failed");
1702       return NULL;
1703     }
1704   }
1705   catch (Standard_Failure) {
1706     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1707     SetErrorCode(aFail->GetMessageString());
1708     return NULL;
1709   }
1710
1711   //Make a Python command
1712   GEOM::TPythonDump(aFunction) << "geompy.Rotate(" << theObject
1713     << ", " << theAxis << ", " << theAngle * 180.0 / M_PI << "*math.pi/180.0)";
1714
1715   SetErrorCode(OK);
1716   return theObject;
1717 }
1718
1719 //=============================================================================
1720 /*!
1721  *  RotateCopy
1722  */
1723 //=============================================================================
1724 Handle(GEOM_Object) GEOMImpl_ITransformOperations::RotateCopy (Handle(GEOM_Object) theObject,
1725                                                                Handle(GEOM_Object) theAxis,
1726                                                                double theAngle)
1727 {
1728   SetErrorCode(KO);
1729
1730   if (theObject.IsNull() || theAxis.IsNull()) return NULL;
1731
1732   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1733   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1734
1735   //Add a new Copy object
1736   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
1737
1738   //Add a rotate function
1739   aFunction = aCopy->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_COPY);
1740   if (aFunction.IsNull()) return NULL;
1741
1742     //Check if the function is set correctly
1743   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1744
1745   GEOMImpl_IRotate aRI(aFunction);
1746   aRI.SetAxis(theAxis->GetLastFunction());
1747   aRI.SetOriginal(aLastFunction);
1748   aRI.SetAngle(theAngle);
1749
1750   //Compute the translation
1751   try {
1752     OCC_CATCH_SIGNALS;
1753     if (!GetSolver()->ComputeFunction(aFunction)) {
1754       SetErrorCode("Rotate driver failed");
1755       return NULL;
1756     }
1757   }
1758   catch (Standard_Failure) {
1759     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1760     SetErrorCode(aFail->GetMessageString());
1761     return NULL;
1762   }
1763
1764   //Make a Python command
1765   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeRotation(" << theObject
1766     << ", " << theAxis << ", " << theAngle * 180.0 / M_PI << "*math.pi/180.0)";
1767
1768   SetErrorCode(OK);
1769   return aCopy;
1770 }
1771
1772 //=============================================================================
1773 /*!
1774  *  Rotate1D (for MultiRotate1DNbTimes)
1775  */
1776 //=============================================================================
1777 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Rotate1D (Handle(GEOM_Object) theObject,
1778                                                              Handle(GEOM_Object) theAxis,
1779                                                              Standard_Integer theNbTimes)
1780 {
1781   SetErrorCode(KO);
1782
1783   if (theObject.IsNull()) return NULL;
1784
1785   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1786   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1787
1788   //Add a new Copy object
1789   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1790
1791   //Add a rotate function
1792   aFunction = aCopy->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_1D);
1793   if (aFunction.IsNull()) return NULL;
1794
1795   //Check if the function is set correctly
1796   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1797
1798   GEOMImpl_IRotate aRI(aFunction);
1799   aRI.SetOriginal(aLastFunction);
1800   if (!theAxis.IsNull())
1801     aRI.SetAxis(theAxis->GetLastFunction());
1802   aRI.SetNbIter1(theNbTimes);
1803
1804   //Compute the translation
1805   try {
1806     OCC_CATCH_SIGNALS;
1807     if (!GetSolver()->ComputeFunction(aFunction)) {
1808       SetErrorCode("Rotate driver failed");
1809       return NULL;
1810     }
1811   }
1812   catch (Standard_Failure) {
1813     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1814     SetErrorCode(aFail->GetMessageString());
1815     return NULL;
1816   }
1817
1818   //Make a Python command
1819   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MultiRotate1DNbTimes("
1820     << theObject << ", " << theAxis << ", " << theNbTimes << ")";
1821
1822   SetErrorCode(OK);
1823   return aCopy;
1824 }
1825
1826 //=============================================================================
1827 /*!
1828  *  Rotate1D (for MultiRotate1DByStep)
1829  */
1830 //=============================================================================
1831 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Rotate1D (Handle(GEOM_Object) theObject,
1832                                                              Handle(GEOM_Object) theAxis,
1833                                                              double theAngleStep,
1834                                                              Standard_Integer theNbSteps)
1835 {
1836   SetErrorCode(KO);
1837
1838   if (theObject.IsNull()) return NULL;
1839
1840   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1841   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1842
1843   //Add a new Copy object
1844   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1845
1846   //Add a rotate function
1847   aFunction = aCopy->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_1D_STEP);
1848   if (aFunction.IsNull()) return NULL;
1849
1850   //Check if the function is set correctly
1851   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1852
1853   //Convert angle into degrees
1854   double anAngleStep = theAngleStep * 180. / M_PI;
1855
1856   GEOMImpl_IRotate aRI (aFunction);
1857   aRI.SetOriginal(aLastFunction);
1858   if (!theAxis.IsNull())
1859     aRI.SetAxis(theAxis->GetLastFunction());
1860   aRI.SetAngle(anAngleStep);
1861   aRI.SetNbIter1(theNbSteps);
1862
1863   //Compute the translation
1864   try {
1865     OCC_CATCH_SIGNALS;
1866     if (!GetSolver()->ComputeFunction(aFunction)) {
1867       SetErrorCode("Rotate driver failed");
1868       return NULL;
1869     }
1870   }
1871   catch (Standard_Failure) {
1872     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1873     SetErrorCode(aFail->GetMessageString());
1874     return NULL;
1875   }
1876
1877   //Make a Python command
1878   GEOM::TPythonDump(aFunction)
1879     << aCopy << " = geompy.MultiRotate1DByStep(" << theObject << ", "
1880     << theAxis << ", " << anAngleStep << "*math.pi/180.0, " << theNbSteps << ")";
1881
1882   SetErrorCode(OK);
1883   return aCopy;
1884 }
1885
1886 //=============================================================================
1887 /*!
1888  *  Rotate2D (for MultiRotate2DNbTimes)
1889  */
1890 //=============================================================================
1891 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Rotate2D (Handle(GEOM_Object) theObject,
1892                                                              Handle(GEOM_Object) theAxis,
1893                                                              Standard_Integer theNbObjects,
1894                                                              double theRadialStep,
1895                                                              Standard_Integer theNbSteps)
1896 {
1897   SetErrorCode(KO);
1898
1899   if (theObject.IsNull()) return NULL;
1900
1901   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1902   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
1903
1904   //Add a new Copy object
1905   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1906
1907   //Add a rotate function
1908   aFunction = aCopy->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_2D);
1909   if (aFunction.IsNull()) return NULL;
1910
1911   //Check if the function is set correctly
1912   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1913
1914   double anAngle = 360. / (double)theNbObjects;
1915
1916   GEOMImpl_IRotate aRI (aFunction);
1917   aRI.SetOriginal(aLastFunction);
1918   if (!theAxis.IsNull())
1919     aRI.SetAxis(theAxis->GetLastFunction());
1920   aRI.SetAngle(anAngle);
1921   aRI.SetNbIter1(theNbObjects);
1922   aRI.SetStep(theRadialStep);
1923   aRI.SetNbIter2(theNbSteps);
1924
1925   //Compute the translation
1926   try {
1927     OCC_CATCH_SIGNALS;
1928     if (!GetSolver()->ComputeFunction(aFunction)) {
1929       SetErrorCode("Rotate driver failed");
1930       return NULL;
1931     }
1932   }
1933   catch (Standard_Failure) {
1934     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1935     SetErrorCode(aFail->GetMessageString());
1936     return NULL;
1937   }
1938
1939   //Make a Python command
1940   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MultiRotate2DNbTimes("
1941                                << theObject << ", " << theAxis << ", " << theNbObjects
1942                                << ", " << theRadialStep << ", " << theNbSteps << ")";
1943
1944   SetErrorCode(OK);
1945   return aCopy;
1946 }
1947
1948 //=============================================================================
1949 /*!
1950  *  Rotate2D (for MultiRotate2DByStep)
1951  */
1952 //=============================================================================
1953 Handle(GEOM_Object) GEOMImpl_ITransformOperations::Rotate2D (Handle(GEOM_Object) theObject,
1954                                                              Handle(GEOM_Object) theAxis,
1955                                                              double theAngleStep,
1956                                                              Standard_Integer theNbTimes1,
1957                                                              double theStep,
1958                                                              Standard_Integer theNbTimes2)
1959 {
1960   SetErrorCode(KO);
1961
1962   if (theObject.IsNull()) return NULL;
1963
1964   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1965   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be rotated
1966
1967   //Add a new Copy object
1968   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1969
1970   //Add a rotate function
1971   aFunction = aCopy->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_2D);
1972   if (aFunction.IsNull()) return NULL;
1973
1974   //Check if the function is set correctly
1975   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
1976
1977   //Convert angle into degrees
1978   double anAngleStep = theAngleStep * 180. / M_PI;
1979
1980   GEOMImpl_IRotate aRI (aFunction);
1981   aRI.SetOriginal(aLastFunction);
1982   if (!theAxis.IsNull())
1983     aRI.SetAxis(theAxis->GetLastFunction());
1984   aRI.SetAngle(anAngleStep);
1985   aRI.SetNbIter1(theNbTimes1);
1986   aRI.SetStep(theStep);
1987   aRI.SetNbIter2(theNbTimes2);
1988
1989   //Compute the translation
1990   try {
1991     OCC_CATCH_SIGNALS;
1992     if (!GetSolver()->ComputeFunction(aFunction)) {
1993       SetErrorCode("Rotate driver failed");
1994       return NULL;
1995     }
1996   }
1997   catch (Standard_Failure) {
1998     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1999     SetErrorCode(aFail->GetMessageString());
2000     return NULL;
2001   }
2002
2003   //Make a Python command
2004   GEOM::TPythonDump(aFunction)
2005     << aCopy << " = geompy.MultiRotate2DByStep(" << theObject << ", "
2006     << theAxis << ", " << anAngleStep << "*math.pi/180.0, "
2007     << theNbTimes1 << ", " << theStep << ", " << theNbTimes2 << ")";
2008
2009   SetErrorCode(OK);
2010   return aCopy;
2011 }
2012
2013 //=============================================================================
2014 /*!
2015  *  RotateThreePoints
2016  */
2017 //=============================================================================
2018 Handle(GEOM_Object) GEOMImpl_ITransformOperations::RotateThreePoints (Handle(GEOM_Object) theObject,
2019                                                                       Handle(GEOM_Object) theCentPoint,
2020                                                                       Handle(GEOM_Object) thePoint1,
2021                                                                       Handle(GEOM_Object) thePoint2)
2022 {
2023   SetErrorCode(KO);
2024
2025   if (theObject.IsNull() || theCentPoint.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
2026
2027   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
2028   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be rotated
2029
2030   // Get last functions of the arguments
2031   Handle(GEOM_Function) aCPF = theCentPoint->GetLastFunction();
2032   Handle(GEOM_Function) aP1F = thePoint1->GetLastFunction();
2033   Handle(GEOM_Function) aP2F = thePoint2->GetLastFunction();
2034
2035
2036   //Add a rotate function
2037   aFunction = theObject->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_THREE_POINTS);
2038
2039   if (aFunction.IsNull()) return NULL;
2040
2041   //Check if the function is set correctly
2042   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
2043
2044   GEOMImpl_IRotate aRI(aFunction);
2045   aRI.SetCentPoint(aCPF);
2046   aRI.SetPoint1(aP1F);
2047   aRI.SetPoint2(aP2F);
2048   aRI.SetOriginal(aLastFunction);
2049
2050   //Compute the translation
2051   try {
2052     OCC_CATCH_SIGNALS;
2053     if (!GetSolver()->ComputeFunction(aFunction)) {
2054       SetErrorCode("Rotate driver failed");
2055       return NULL;
2056     }
2057   }
2058   catch (Standard_Failure) {
2059     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2060     SetErrorCode(aFail->GetMessageString());
2061     return NULL;
2062   }
2063
2064   //Make a Python command
2065   GEOM::TPythonDump(aFunction) << "geompy.RotateThreePoints(" << theObject
2066                                << ", " << theCentPoint << ", "<<thePoint1 << ", " << thePoint2 << ")";
2067
2068   SetErrorCode(OK);
2069   return theObject;
2070 }
2071
2072 //=============================================================================
2073 /*!
2074  *  RotateThreePointsCopy
2075  */
2076 //=============================================================================
2077 Handle(GEOM_Object) GEOMImpl_ITransformOperations::RotateThreePointsCopy (Handle(GEOM_Object) theObject,
2078                                                          Handle(GEOM_Object) theCentPoint,
2079                                                          Handle(GEOM_Object) thePoint1,
2080                                                          Handle(GEOM_Object) thePoint2)
2081 {
2082   SetErrorCode(KO);
2083
2084   if (theObject.IsNull() || theCentPoint.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
2085
2086   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
2087   if (aLastFunction.IsNull()) return NULL;  //There is no function which creates an object to be rotated
2088
2089   //Add a new Copy object
2090   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
2091
2092   //Add a rotate function
2093   aFunction = aCopy->AddFunction(GEOMImpl_RotateDriver::GetID(), ROTATE_THREE_POINTS_COPY);
2094   if (aFunction.IsNull()) return NULL;
2095
2096     //Check if the function is set correctly
2097   if (aFunction->GetDriverGUID() != GEOMImpl_RotateDriver::GetID()) return NULL;
2098
2099   GEOMImpl_IRotate aRI(aFunction);
2100   aRI.SetCentPoint(theCentPoint->GetLastFunction());
2101   aRI.SetPoint1(thePoint1->GetLastFunction());
2102   aRI.SetPoint2(thePoint2->GetLastFunction());
2103   aRI.SetOriginal(aLastFunction);
2104
2105   //Compute the translation
2106   try {
2107     OCC_CATCH_SIGNALS;
2108     if (!GetSolver()->ComputeFunction(aFunction)) {
2109       SetErrorCode("Rotate driver failed");
2110       return NULL;
2111     }
2112   }
2113   catch (Standard_Failure) {
2114     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2115     SetErrorCode(aFail->GetMessageString());
2116     return NULL;
2117   }
2118
2119   //Make a Python command
2120   GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeRotationThreePoints(" << theObject
2121                                << ", " << theCentPoint << ", "<<thePoint1 << ", " << thePoint2 << ")";
2122
2123   SetErrorCode(OK);
2124   return aCopy;
2125 }
2126
2127 //=============================================================================
2128 /*!
2129  *  TransformLikeOtherCopy
2130  */
2131 //=============================================================================
2132 Handle(GEOM_Object) GEOMImpl_ITransformOperations::TransformLikeOtherCopy
2133                                                 (Handle(GEOM_Object) theObject,
2134                                                  Handle(GEOM_Object) theSample)
2135 {
2136   SetErrorCode(KO);
2137
2138   if (theObject.IsNull() || theSample.IsNull()) return NULL;
2139
2140   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
2141   if (aLastFunction.IsNull()) return NULL; // There is no function which creates an object to be transformed
2142
2143   Handle(GEOM_Function) aSampleFunc = theSample->GetLastFunction();
2144   if (aSampleFunc.IsNull()) return NULL; // There is no function which creates a sample object
2145
2146   // Add a new Copy object
2147   Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
2148
2149   // Add a transform function (depends on theSample function)
2150   Handle(GEOM_Function) aFunction =
2151     aCopy->AddFunction(aSampleFunc->GetDriverGUID(), aSampleFunc->GetType());
2152   if (aFunction.IsNull()) return NULL;
2153
2154   // Check if the function is set correctly
2155   if (aFunction->GetDriverGUID() != aSampleFunc->GetDriverGUID()) return NULL;
2156
2157   if (aSampleFunc->GetDriverGUID() == GEOMImpl_TranslateDriver::GetID()) {
2158     switch (aSampleFunc->GetType()) {
2159     case TRANSLATE_1D:
2160       {
2161         GEOMImpl_ITranslate aRI_sample (aSampleFunc);
2162         GEOMImpl_ITranslate aRI_target (aFunction);
2163
2164         aRI_target.SetVector(aRI_sample.GetVector());
2165         aRI_target.SetStep1(aRI_sample.GetStep1());
2166         aRI_target.SetNbIter1(aRI_sample.GetNbIter1());
2167
2168         aRI_target.SetOriginal(aLastFunction);
2169       }
2170       break;
2171     case TRANSLATE_2D:
2172       {
2173         GEOMImpl_ITranslate aRI_sample (aSampleFunc);
2174         GEOMImpl_ITranslate aRI_target (aFunction);
2175
2176         aRI_target.SetVector(aRI_sample.GetVector());
2177         aRI_target.SetStep1(aRI_sample.GetStep1());
2178         aRI_target.SetNbIter1(aRI_sample.GetNbIter1());
2179
2180         aRI_target.SetVector2(aRI_sample.GetVector2());
2181         aRI_target.SetStep2(aRI_sample.GetStep2());
2182         aRI_target.SetNbIter2(aRI_sample.GetNbIter2());
2183
2184         aRI_target.SetOriginal(aLastFunction);
2185       }
2186       break;
2187     default:
2188       {
2189         SetErrorCode("Not implemented case of TransformLikeOtherCopy");
2190         return NULL;
2191       }
2192     }
2193   }
2194   else if (aSampleFunc->GetDriverGUID() == GEOMImpl_RotateDriver::GetID()) {
2195     switch (aSampleFunc->GetType()) {
2196     case ROTATE_1D:
2197       {
2198         GEOMImpl_IRotate aRI_sample (aSampleFunc);
2199         GEOMImpl_IRotate aRI_target (aFunction);
2200
2201         aRI_target.SetAxis(aRI_sample.GetAxis());
2202         aRI_target.SetNbIter1(aRI_sample.GetNbIter1());
2203
2204         aRI_target.SetOriginal(aLastFunction);
2205       }
2206       break;
2207     case ROTATE_2D:
2208       {
2209         GEOMImpl_IRotate aRI_sample (aSampleFunc);
2210         GEOMImpl_IRotate aRI_target (aFunction);
2211
2212         aRI_target.SetAxis(aRI_sample.GetAxis());
2213
2214         aRI_target.SetNbIter1(aRI_sample.GetNbIter1());
2215         aRI_target.SetNbIter2(aRI_sample.GetNbIter2());
2216
2217         aRI_target.SetAngle(aRI_sample.GetAngle());
2218         aRI_target.SetStep(aRI_sample.GetStep());
2219
2220         aRI_target.SetDir2(aRI_sample.GetDir2());
2221
2222         aRI_target.SetOriginal(aLastFunction);
2223       }
2224       break;
2225     case ROTATE_THREE_POINTS_COPY:
2226       {
2227         GEOMImpl_IRotate aRI_sample (aSampleFunc);
2228         GEOMImpl_IRotate aRI_target (aFunction);
2229
2230         aRI_target.SetCentPoint(aRI_sample.GetCentPoint());
2231         aRI_target.SetPoint1(aRI_sample.GetPoint1());
2232         aRI_target.SetPoint2(aRI_sample.GetPoint2());
2233
2234         aRI_target.SetOriginal(aLastFunction);
2235       }
2236       break;
2237     default:
2238       {
2239         SetErrorCode("Not implemented case of TransformLikeOtherCopy");
2240         return NULL;
2241       }
2242     }
2243   }
2244   else {
2245     SetErrorCode("Not implemented case of TransformLikeOtherCopy");
2246     return NULL;
2247   }
2248
2249   // Compute the transformation
2250   try {
2251     OCC_CATCH_SIGNALS;
2252     if (!GetSolver()->ComputeFunction(aFunction)) {
2253       SetErrorCode("Driver failed");
2254       return NULL;
2255     }
2256   }
2257   catch (Standard_Failure) {
2258     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2259     SetErrorCode(aFail->GetMessageString());
2260     return NULL;
2261   }
2262
2263   //Make a Python command
2264   //GEOM::TPythonDump(aFunction) << aCopy << " = geompy.TransformLikeOtherCopy("
2265   //                             << theObject << ", " << theSample << ")";
2266
2267   SetErrorCode(OK);
2268   return aCopy;
2269 }
2270
2271 //=============================================================================
2272 /*!
2273  *  MakeProjectionOnCylinder
2274  */
2275 //=============================================================================
2276 Handle(GEOM_Object) GEOMImpl_ITransformOperations::MakeProjectionOnCylinder
2277                              (const Handle(GEOM_Object) &theObject,
2278                               const Standard_Real        theRadius,
2279                               const Standard_Real        theStartAngle,
2280                               const Standard_Real        theAngleLength,
2281                               const Standard_Real        theAngleRotation)
2282 {
2283   SetErrorCode(KO);
2284
2285   if (theObject.IsNull()) {
2286     return NULL;
2287   }
2288
2289   Handle(GEOM_Function) aLastFunction = theObject->GetLastFunction();
2290
2291   if (aLastFunction.IsNull()) {
2292     //There is no function which creates an object to be projected
2293     return NULL;
2294   }
2295
2296   //Add a new Projection object
2297   Handle(GEOM_Object) aResult =
2298     GetEngine()->AddObject(GetDocID(), GEOM_PROJECTION);
2299
2300   //Add a Projection function
2301   Handle(GEOM_Function) aFunction = aResult->AddFunction
2302     (GEOMImpl_ProjectionDriver::GetID(), PROJECTION_ON_CYLINDER);
2303
2304   //Check if the function is set correctly
2305   if (aFunction->GetDriverGUID() != GEOMImpl_ProjectionDriver::GetID()) {
2306     return aResult;
2307   }
2308
2309   GEOMImpl_IProjOnCyl aProj (aFunction);
2310
2311   aProj.SetShape(aLastFunction);
2312   aProj.SetRadius(theRadius);
2313   aProj.SetStartAngle(theStartAngle);
2314   aProj.SetAngleLength(theAngleLength);
2315   aProj.SetAngleRotation(theAngleRotation);
2316
2317   //Compute the Projection
2318   try {
2319     OCC_CATCH_SIGNALS;
2320     if (!GetSolver()->ComputeFunction(aFunction)) {
2321       SetErrorCode("Projection driver failed");
2322       return aResult;
2323     }
2324   }
2325   catch (Standard_Failure) {
2326     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2327     SetErrorCode(aFail->GetMessageString());
2328     return aResult;
2329   }
2330
2331   //Make a Python command
2332   GEOM::TPythonDump(aFunction)
2333     << aResult << " = geompy.MakeProjectionOnCylinder("
2334     << theObject << ", " << theRadius << ", " << theStartAngle
2335     << ", " << theAngleLength << ", " << theAngleRotation << ")";
2336
2337   SetErrorCode(OK);
2338
2339   return aResult;
2340 }