]> SALOME platform Git repositories - modules/geom.git/blob - src/GEOMImpl/GEOMImpl_ICurvesOperations.cxx
Salome HOME
XAO test fixed to work in salome test
[modules/geom.git] / src / GEOMImpl / GEOMImpl_ICurvesOperations.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 #ifdef WIN32
24 // E.A. : On windows with python 2.6, there is a conflict
25 // E.A. : between pymath.h and Standard_math.h which define
26 // E.A. : some same symbols : acosh, asinh, ...
27 #include <Standard_math.hxx>
28 #include <pymath.h>
29 #endif
30
31 #include <Python.h>
32 #include <structmember.h>
33
34 #ifdef HAVE_FINITE
35 #undef HAVE_FINITE
36 #endif
37
38 #include "GEOMImpl_ICurvesOperations.hxx"
39 #include "GEOMImpl_Types.hxx"
40
41 #include "GEOM_Function.hxx"
42 #include "GEOM_PythonDump.hxx"
43
44 #include "GEOMImpl_PolylineDriver.hxx"
45 #include "GEOMImpl_CircleDriver.hxx"
46 #include "GEOMImpl_SplineDriver.hxx"
47 #include "GEOMImpl_EllipseDriver.hxx"
48 #include "GEOMImpl_ArcDriver.hxx"
49 #include "GEOMImpl_ShapeDriver.hxx"
50 #include "GEOMImpl_SketcherDriver.hxx"
51 #include "GEOMImpl_3DSketcherDriver.hxx"
52
53 #include "GEOMImpl_IPolyline.hxx"
54 #include "GEOMImpl_IPolyline2D.hxx"
55 #include "GEOMImpl_ICircle.hxx"
56 #include "GEOMImpl_ISpline.hxx"
57 #include "GEOMImpl_IEllipse.hxx"
58 #include "GEOMImpl_IArc.hxx"
59 #include "GEOMImpl_ISketcher.hxx"
60 #include "GEOMImpl_I3DSketcher.hxx"
61 #include "GEOMImpl_ICurveParametric.hxx"
62 #include "GEOMImpl_IIsoline.hxx"
63 #include "GEOMImpl_PolylineDumper.hxx"
64
65 #include <Basics_OCCTVersion.hxx>
66
67 #include "utilities.h"
68
69 #include <TDF_Tool.hxx>
70 #include <TColStd_HArray1OfByte.hxx>
71 #include <TColStd_HArray1OfReal.hxx>
72
73 #include <Standard_Failure.hxx>
74 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
75
76
77 /* ==================================
78  * ===========  PYTHON ==============
79  * ==================================*/
80
81 namespace
82 {
83   typedef struct {
84     PyObject_HEAD
85     int softspace;
86     std::string *out;
87   } PyStdOut;
88   
89   static void
90   PyStdOut_dealloc(PyStdOut *self)
91   {
92     PyObject_Del(self);
93   }
94
95   static PyObject*
96   PyStdOut_write(PyStdOut* self, PyObject* args)
97   {
98     char *c;
99     int l;
100     if (!PyArg_ParseTuple(args, "t#:write", &c, &l))
101       return NULL;
102     
103     *(self->out) = *(self->out) + c;
104     
105     Py_INCREF(Py_None);
106     return Py_None;
107   }
108   
109   static PyMethodDef PyStdOut_methods[] = {
110     {"write",  (PyCFunction)PyStdOut_write,  METH_VARARGS,
111      PyDoc_STR("write(string) -> None")},
112     {NULL,    NULL}   /* sentinel */
113   };
114
115   static PyMemberDef PyStdOut_memberlist[] = {
116     {(char*)"softspace", T_INT,  offsetof(PyStdOut, softspace), 0,
117      (char*)"flag indicating that a space needs to be printed; used by print"},
118     {NULL} /* Sentinel */
119   };
120   
121   static PyTypeObject PyStdOut_Type = {
122     /* The ob_type field must be initialized in the module init function
123      * to be portable to Windows without using C++. */
124     PyObject_HEAD_INIT(NULL)
125     0,                            /*ob_size*/
126     "PyOut",                      /*tp_name*/
127     sizeof(PyStdOut),             /*tp_basicsize*/
128     0,                            /*tp_itemsize*/
129     /* methods */
130     (destructor)PyStdOut_dealloc, /*tp_dealloc*/
131     0,                            /*tp_print*/
132     0,                            /*tp_getattr*/
133     0,                            /*tp_setattr*/
134     0,                            /*tp_compare*/
135     0,                            /*tp_repr*/
136     0,                            /*tp_as_number*/
137     0,                            /*tp_as_sequence*/
138     0,                            /*tp_as_mapping*/
139     0,                            /*tp_hash*/
140     0,                            /*tp_call*/
141     0,                            /*tp_str*/
142     PyObject_GenericGetAttr,      /*tp_getattro*/
143     /* softspace is writable:  we must supply tp_setattro */
144     PyObject_GenericSetAttr,      /* tp_setattro */
145     0,                            /*tp_as_buffer*/
146     Py_TPFLAGS_DEFAULT,           /*tp_flags*/
147     0,                            /*tp_doc*/
148     0,                            /*tp_traverse*/
149     0,                            /*tp_clear*/
150     0,                            /*tp_richcompare*/
151     0,                            /*tp_weaklistoffset*/
152     0,                            /*tp_iter*/
153     0,                            /*tp_iternext*/
154     PyStdOut_methods,             /*tp_methods*/
155     PyStdOut_memberlist,          /*tp_members*/
156     0,                            /*tp_getset*/
157     0,                            /*tp_base*/
158     0,                            /*tp_dict*/
159     0,                            /*tp_descr_get*/
160     0,                            /*tp_descr_set*/
161     0,                            /*tp_dictoffset*/
162     0,                            /*tp_init*/
163     0,                            /*tp_alloc*/
164     0,                            /*tp_new*/
165     0,                            /*tp_free*/
166     0,                            /*tp_is_gc*/
167   };
168   
169   PyObject* newPyStdOut( std::string& out )
170   {
171     PyStdOut* self = PyObject_New(PyStdOut, &PyStdOut_Type);
172     if (self) {
173       self->softspace = 0;
174       self->out=&out;
175     }
176     return (PyObject*)self;
177   }
178 }
179
180 ////////////////////////END PYTHON///////////////////////////
181 //=============================================================================
182 /*!
183  *   constructor:
184  */
185 //=============================================================================
186 GEOMImpl_ICurvesOperations::GEOMImpl_ICurvesOperations (GEOM_Engine* theEngine, int theDocID)
187 : GEOM_IOperations(theEngine, theDocID)
188 {
189   MESSAGE("GEOMImpl_ICurvesOperations::GEOMImpl_ICurvesOperations");
190 }
191
192 //=============================================================================
193 /*!
194  *  destructor
195  */
196 //=============================================================================
197 GEOMImpl_ICurvesOperations::~GEOMImpl_ICurvesOperations()
198 {
199   MESSAGE("GEOMImpl_ICurvesOperations::~GEOMImpl_ICurvesOperations");
200 }
201
202
203 //=============================================================================
204 /*!
205  *  MakeCircleThreePnt
206  */
207 //=============================================================================
208 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeCircleThreePnt (Handle(GEOM_Object) thePnt1,
209                                                                     Handle(GEOM_Object) thePnt2,
210                                                                     Handle(GEOM_Object) thePnt3)
211 {
212   SetErrorCode(KO);
213
214   if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
215
216   //Add a new Circle object
217   Handle(GEOM_Object) aCircle = GetEngine()->AddObject(GetDocID(), GEOM_CIRCLE);
218
219   //Add a new Circle function for creation a circle relatively to three points
220   Handle(GEOM_Function) aFunction =
221     aCircle->AddFunction(GEOMImpl_CircleDriver::GetID(), CIRCLE_THREE_PNT);
222   if (aFunction.IsNull()) return NULL;
223
224   //Check if the function is set correctly
225   if (aFunction->GetDriverGUID() != GEOMImpl_CircleDriver::GetID()) return NULL;
226
227   GEOMImpl_ICircle aCI (aFunction);
228
229   Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
230   Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
231   Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
232
233   if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
234
235   aCI.SetPoint1(aRefPnt1);
236   aCI.SetPoint2(aRefPnt2);
237   aCI.SetPoint3(aRefPnt3);
238
239   //Compute the Circle value
240   try {
241     OCC_CATCH_SIGNALS;
242     if (!GetSolver()->ComputeFunction(aFunction)) {
243       SetErrorCode("Circle driver failed");
244       return NULL;
245     }
246   }
247   catch (Standard_Failure) {
248     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
249     SetErrorCode(aFail->GetMessageString());
250     return NULL;
251   }
252
253   //Make a Python command
254   GEOM::TPythonDump(aFunction) << aCircle << " = geompy.MakeCircleThreePnt("
255     << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << ")";
256
257   SetErrorCode(OK);
258   return aCircle;
259 }
260
261 //=============================================================================
262 /*!
263  *  MakeCircleCenter2Pnt
264  */
265 //=============================================================================
266 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeCircleCenter2Pnt (Handle(GEOM_Object) thePnt1,
267                                                                       Handle(GEOM_Object) thePnt2,
268                                                                       Handle(GEOM_Object) thePnt3)
269 {
270   SetErrorCode(KO);
271
272   if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
273
274   //Add a new Circle object
275   Handle(GEOM_Object) aCircle = GetEngine()->AddObject(GetDocID(), GEOM_CIRCLE);
276
277   //Add a new Circle function for creation a circle relatively to center and 2 points
278   Handle(GEOM_Function) aFunction =
279     aCircle->AddFunction(GEOMImpl_CircleDriver::GetID(), CIRCLE_CENTER_TWO_PNT);
280   if (aFunction.IsNull()) return NULL;
281
282   //Check if the function is set correctly
283   if (aFunction->GetDriverGUID() != GEOMImpl_CircleDriver::GetID()) return NULL;
284
285   GEOMImpl_ICircle aCI (aFunction);
286
287   Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
288   Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
289   Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
290
291   if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
292
293   aCI.SetPoint1(aRefPnt1);
294   aCI.SetPoint2(aRefPnt2);
295   aCI.SetPoint3(aRefPnt3);
296
297   //Compute the Circle value
298   try {
299     OCC_CATCH_SIGNALS;
300     if (!GetSolver()->ComputeFunction(aFunction)) {
301       SetErrorCode("Circle driver failed");
302       return NULL;
303     }
304   }
305   catch (Standard_Failure) {
306     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
307     SetErrorCode(aFail->GetMessageString());
308     return NULL;
309   }
310
311   //Make a Python command
312   GEOM::TPythonDump(aFunction) << aCircle << " = geompy.MakeCircleCenter2Pnt("
313     << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << ")";
314
315   SetErrorCode(OK);
316   return aCircle;
317 }
318
319 //=============================================================================
320 /*!
321  *  MakeCirclePntVecR
322  */
323 //=============================================================================
324 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeCirclePntVecR
325        (Handle(GEOM_Object) thePnt, Handle(GEOM_Object) theVec, double theR)
326 {
327   SetErrorCode(KO);
328
329   // Not set thePnt means origin of global CS,
330   // Not set theVec means Z axis of global CS
331   //if (thePnt.IsNull() || theVec.IsNull()) return NULL;
332
333   //Add a new Circle object
334   Handle(GEOM_Object) aCircle = GetEngine()->AddObject(GetDocID(), GEOM_CIRCLE);
335
336   //Add a new Circle function for creation a circle relatively to point and vector
337   Handle(GEOM_Function) aFunction =
338     aCircle->AddFunction(GEOMImpl_CircleDriver::GetID(), CIRCLE_PNT_VEC_R);
339   if (aFunction.IsNull()) return NULL;
340
341   //Check if the function is set correctly
342   if (aFunction->GetDriverGUID() != GEOMImpl_CircleDriver::GetID()) return NULL;
343
344   GEOMImpl_ICircle aCI (aFunction);
345
346   if (!thePnt.IsNull()) {
347     Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
348     if (aRefPnt.IsNull()) return NULL;
349     aCI.SetCenter(aRefPnt);
350   }
351
352   if (!theVec.IsNull()) {
353     Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
354     if (aRefVec.IsNull()) return NULL;
355     aCI.SetVector(aRefVec);
356   }
357
358   aCI.SetRadius(theR);
359
360   //Compute the Circle value
361   try {
362     OCC_CATCH_SIGNALS;
363     if (!GetSolver()->ComputeFunction(aFunction)) {
364       SetErrorCode("Circle driver failed");
365       return NULL;
366     }
367   }
368   catch (Standard_Failure) {
369     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
370     SetErrorCode(aFail->GetMessageString());
371     return NULL;
372   }
373
374   //Make a Python command
375   GEOM::TPythonDump(aFunction) << aCircle << " = geompy.MakeCircle("
376     << thePnt << ", " << theVec << ", " << theR << ")";
377
378   SetErrorCode(OK);
379   return aCircle;
380 }
381
382 //=============================================================================
383 /*!
384  *  MakeEllipse
385  */
386 //=============================================================================
387 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeEllipse
388                        (Handle(GEOM_Object) thePnt, Handle(GEOM_Object) theVec,
389                         double theRMajor, double theRMinor,
390                         Handle(GEOM_Object) theVecMaj)
391 {
392   SetErrorCode(KO);
393
394   // Not set thePnt means origin of global CS,
395   // Not set theVec means Z axis of global CS
396   // Not set theVecMaj means X axis of global CS
397   //if (thePnt.IsNull() || theVec.IsNull()) return NULL;
398
399   //Add a new Ellipse object
400   Handle(GEOM_Object) anEll = GetEngine()->AddObject(GetDocID(), GEOM_ELLIPSE);
401
402   //Add a new Ellipse function
403   Handle(GEOM_Function) aFunction =
404     anEll->AddFunction(GEOMImpl_EllipseDriver::GetID(), ELLIPSE_PNT_VEC_RR);
405   if (aFunction.IsNull()) return NULL;
406
407   //Check if the function is set correctly
408   if (aFunction->GetDriverGUID() != GEOMImpl_EllipseDriver::GetID()) return NULL;
409
410   GEOMImpl_IEllipse aCI (aFunction);
411
412   if (!thePnt.IsNull()) {
413     Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
414     if (aRefPnt.IsNull()) return NULL;
415     aCI.SetCenter(aRefPnt);
416   }
417
418   if (!theVec.IsNull()) {
419     Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
420     if (aRefVec.IsNull()) return NULL;
421     aCI.SetVector(aRefVec);
422   }
423
424   aCI.SetRMajor(theRMajor);
425   aCI.SetRMinor(theRMinor);
426
427   if (!theVecMaj.IsNull()) {
428     Handle(GEOM_Function) aRefVecMaj = theVecMaj->GetLastFunction();
429     if (aRefVecMaj.IsNull()) return NULL;
430     aCI.SetVectorMajor(aRefVecMaj);
431   }
432
433   //Compute the Ellipse value
434   try {
435     OCC_CATCH_SIGNALS;
436     if (!GetSolver()->ComputeFunction(aFunction)) {
437       SetErrorCode("Ellipse driver failed");
438       return NULL;
439     }
440   }
441   catch (Standard_Failure) {
442     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
443     SetErrorCode(aFail->GetMessageString());
444     return NULL;
445   }
446
447   //Make a Python command
448   if (!theVecMaj.IsNull()) {
449     GEOM::TPythonDump(aFunction) << anEll << " = geompy.MakeEllipse("
450                                  << thePnt << ", " << theVec << ", " << theRMajor << ", " << theRMinor
451                                  << ", " << theVecMaj << ")";
452   }
453   else {
454     GEOM::TPythonDump(aFunction) << anEll << " = geompy.MakeEllipse("
455                                  << thePnt << ", " << theVec << ", " << theRMajor << ", " << theRMinor << ")";
456   }
457
458   SetErrorCode(OK);
459   return anEll;
460 }
461
462 //=============================================================================
463 /*!
464  *  MakeArc
465  */
466 //=============================================================================
467 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeArc (Handle(GEOM_Object) thePnt1,
468                                                          Handle(GEOM_Object) thePnt2,
469                                                          Handle(GEOM_Object) thePnt3)
470 {
471   SetErrorCode(KO);
472
473   if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
474
475   //Add a new Circle Arc object
476   Handle(GEOM_Object) anArc = GetEngine()->AddObject(GetDocID(), GEOM_CIRC_ARC);
477
478   //Add a new Circle Arc function
479   Handle(GEOM_Function) aFunction =
480       anArc->AddFunction(GEOMImpl_ArcDriver::GetID(), CIRC_ARC_THREE_PNT);
481
482   if (aFunction.IsNull()) return NULL;
483
484   //Check if the function is set correctly
485   if (aFunction->GetDriverGUID() != GEOMImpl_ArcDriver::GetID()) return NULL;
486   GEOMImpl_IArc aCI (aFunction);
487
488   Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
489   Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
490   Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
491
492   if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
493
494   aCI.SetPoint1(aRefPnt1);
495   aCI.SetPoint2(aRefPnt2);
496   aCI.SetPoint3(aRefPnt3);
497
498   //Compute the Arc value
499   try {
500     OCC_CATCH_SIGNALS;
501     if (!GetSolver()->ComputeFunction(aFunction)) {
502       SetErrorCode("Arc driver failed");
503       return NULL;
504     }
505   }
506   catch (Standard_Failure) {
507     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
508     SetErrorCode(aFail->GetMessageString());
509     return NULL;
510   }
511
512   //Make a Python command
513   GEOM::TPythonDump(aFunction) << anArc << " = geompy.MakeArc("
514     << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << ")";
515
516   SetErrorCode(OK);
517   return anArc;
518 }
519
520 //=============================================================================
521 /*!
522  *  MakeArcCenter
523  */
524 //=============================================================================
525 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeArcCenter (Handle(GEOM_Object) thePnt1,
526                                                                Handle(GEOM_Object) thePnt2,
527                                                                Handle(GEOM_Object) thePnt3,
528                                                                bool                theSense)
529 {
530   SetErrorCode(KO);
531   if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
532
533   //Add a new Circle Arc object
534   Handle(GEOM_Object) anArc = GetEngine()->AddObject(GetDocID(), GEOM_CIRC_ARC);
535
536   //Add a new Circle Arc function
537   Handle(GEOM_Function) aFunction =
538       anArc->AddFunction(GEOMImpl_ArcDriver::GetID(), CIRC_ARC_CENTER);
539   if (aFunction.IsNull()) return NULL;
540
541   //Check if the function is set correctly
542   if (aFunction->GetDriverGUID() != GEOMImpl_ArcDriver::GetID()) return NULL;
543
544   GEOMImpl_IArc aCI (aFunction);
545
546   Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
547   Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
548   Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
549
550   if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
551
552   aCI.SetPoint1(aRefPnt1);
553   aCI.SetPoint2(aRefPnt2);
554   aCI.SetPoint3(aRefPnt3);
555   aCI.SetSense(theSense);
556
557   //Compute the Arc value
558   try {
559     OCC_CATCH_SIGNALS;
560     if (!GetSolver()->ComputeFunction(aFunction)) {
561       SetErrorCode("Arc driver failed");
562       return NULL;
563     }
564   }
565   catch (Standard_Failure) {
566     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
567     SetErrorCode(aFail->GetMessageString());
568     return NULL;
569   }
570   //Make a Python command
571   GEOM::TPythonDump(aFunction) << anArc << " = geompy.MakeArcCenter("
572       << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << "," << theSense << ")";
573
574   SetErrorCode(OK);
575   return anArc;
576 }
577
578 //=============================================================================
579 /*!
580  *  MakeArcOfEllipse
581  */
582 //=============================================================================
583 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeArcOfEllipse (Handle(GEOM_Object) thePnt1,
584                                                                   Handle(GEOM_Object) thePnt2,
585                                                                   Handle(GEOM_Object) thePnt3)
586 {
587   SetErrorCode(KO);
588
589   if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
590
591   //Add a new Circle Arc object
592   Handle(GEOM_Object) anArc = GetEngine()->AddObject(GetDocID(), GEOM_ELLIPSE_ARC);
593
594   //Add a new Circle Arc function
595   Handle(GEOM_Function) aFunction =
596       anArc->AddFunction(GEOMImpl_ArcDriver::GetID(), ELLIPSE_ARC_CENTER_TWO_PNT);
597
598   if (aFunction.IsNull()) return NULL;
599
600   //Check if the function is set correctly
601   if (aFunction->GetDriverGUID() != GEOMImpl_ArcDriver::GetID()) return NULL;
602   GEOMImpl_IArc aCI (aFunction);
603
604   Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
605   Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
606   Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
607
608   if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
609
610   aCI.SetPoint1(aRefPnt1);
611   aCI.SetPoint2(aRefPnt2);
612   aCI.SetPoint3(aRefPnt3);
613
614   //Compute the Arc value
615   try {
616     OCC_CATCH_SIGNALS;
617     if (!GetSolver()->ComputeFunction(aFunction)) {
618       SetErrorCode("Arc 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) << anArc << " = geompy.MakeArcOfEllipse("
630     << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << ")";
631
632   SetErrorCode(OK);
633   return anArc;
634 }
635
636 //=============================================================================
637 /*!
638  *  MakePolyline
639  */
640 //=============================================================================
641 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakePolyline (std::list<Handle(GEOM_Object)> thePoints,
642                                                               bool theIsClosed)
643 {
644   SetErrorCode(KO);
645
646   //Add a new Polyline object
647   Handle(GEOM_Object) aPolyline = GetEngine()->AddObject(GetDocID(), GEOM_POLYLINE);
648
649   //Add a new Polyline function for creation a polyline relatively to points set
650   Handle(GEOM_Function) aFunction =
651     aPolyline->AddFunction(GEOMImpl_PolylineDriver::GetID(), POLYLINE_POINTS);
652   if (aFunction.IsNull()) return NULL;
653
654   //Check if the function is set correctly
655   if (aFunction->GetDriverGUID() != GEOMImpl_PolylineDriver::GetID()) return NULL;
656
657   GEOMImpl_IPolyline aCI (aFunction);
658
659   int aLen = thePoints.size();
660   aCI.SetLength(aLen);
661   aCI.SetConstructorType(POINT_CONSTRUCTOR);
662
663   int ind = 1;
664   std::list<Handle(GEOM_Object)>::iterator it = thePoints.begin();
665   for (; it != thePoints.end(); it++, ind++) {
666     Handle(GEOM_Function) aRefPnt = (*it)->GetLastFunction();
667     if (aRefPnt.IsNull()) {
668       SetErrorCode("NULL point for Polyline");
669       return NULL;
670     }
671     aCI.SetPoint(ind, aRefPnt);
672   }
673
674   aCI.SetIsClosed(theIsClosed);
675
676   //Compute the Polyline value
677   try {
678     OCC_CATCH_SIGNALS;
679     if (!GetSolver()->ComputeFunction(aFunction)) {
680       SetErrorCode("Polyline driver failed");
681       return NULL;
682     }
683   }
684   catch (Standard_Failure) {
685     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
686     SetErrorCode(aFail->GetMessageString());
687     return NULL;
688   }
689
690   //Make a Python command
691   GEOM::TPythonDump pd (aFunction);
692   pd << aPolyline << " = geompy.MakePolyline([";
693
694   it = thePoints.begin();
695   pd << (*it++);
696   while (it != thePoints.end()) {
697     pd << ", " << (*it++);
698   }
699   pd << "], " << theIsClosed << ")";
700
701   SetErrorCode(OK);
702   return aPolyline;
703 }
704
705 //=============================================================================
706 /*!
707  *  MakeSplineBezier
708  */
709 //=============================================================================
710 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeSplineBezier
711                                           (std::list<Handle(GEOM_Object)> thePoints,
712                                            bool theIsClosed)
713 {
714   SetErrorCode(KO);
715
716   //Add a new Spline object
717   Handle(GEOM_Object) aSpline = GetEngine()->AddObject(GetDocID(), GEOM_SPLINE);
718
719   //Add a new Spline function for creation a bezier curve relatively to points set
720   Handle(GEOM_Function) aFunction =
721     aSpline->AddFunction(GEOMImpl_SplineDriver::GetID(), SPLINE_BEZIER);
722   if (aFunction.IsNull()) return NULL;
723
724   //Check if the function is set correctly
725   if (aFunction->GetDriverGUID() != GEOMImpl_SplineDriver::GetID()) return NULL;
726
727   GEOMImpl_ISpline aCI (aFunction);
728
729   aCI.SetConstructorType(POINT_CONSTRUCTOR);
730
731   Handle(TColStd_HSequenceOfTransient) aPoints = new TColStd_HSequenceOfTransient;
732   std::list<Handle(GEOM_Object)>::iterator it = thePoints.begin();
733   for (; it != thePoints.end(); it++) {
734     Handle(GEOM_Function) aRefPnt = (*it)->GetLastFunction();
735     if (aRefPnt.IsNull()) {
736       SetErrorCode("NULL point for Besier curve");
737       return NULL;
738     }
739     aPoints->Append(aRefPnt);
740   }
741   aCI.SetPoints(aPoints);
742
743   aCI.SetIsClosed(theIsClosed);
744
745   //Compute the Spline value
746   try {
747     OCC_CATCH_SIGNALS;
748     if (!GetSolver()->ComputeFunction(aFunction)) {
749       SetErrorCode("Spline driver failed");
750       return NULL;
751     }
752   }
753   catch (Standard_Failure) {
754     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
755     SetErrorCode(aFail->GetMessageString());
756     return NULL;
757   }
758
759   //Make a Python command
760   GEOM::TPythonDump pd (aFunction);
761   pd << aSpline << " = geompy.MakeBezier([";
762
763   it = thePoints.begin();
764   pd << (*it++);
765   while (it != thePoints.end()) {
766     pd << ", " << (*it++);
767   }
768   pd << "], " << theIsClosed << ")";
769
770   SetErrorCode(OK);
771   return aSpline;
772 }
773
774 //=============================================================================
775 /*!
776  *  MakeSplineInterpolation
777  */
778 //=============================================================================
779 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeSplineInterpolation
780                                           (std::list<Handle(GEOM_Object)> thePoints,
781                                            bool theIsClosed,
782                                            bool theDoReordering)
783 {
784   SetErrorCode(KO);
785
786   //Add a new Spline object
787   Handle(GEOM_Object) aSpline = GetEngine()->AddObject(GetDocID(), GEOM_SPLINE);
788
789   //Add a new Spline function for interpolation type
790   Handle(GEOM_Function) aFunction =
791     aSpline->AddFunction(GEOMImpl_SplineDriver::GetID(), SPLINE_INTERPOLATION);
792   if (aFunction.IsNull()) return NULL;
793
794   //Check if the function is set correctly
795   if (aFunction->GetDriverGUID() != GEOMImpl_SplineDriver::GetID()) return NULL;
796
797   GEOMImpl_ISpline aCI (aFunction);
798
799   aCI.SetConstructorType(POINT_CONSTRUCTOR);
800
801   Handle(TColStd_HSequenceOfTransient) aPoints = new TColStd_HSequenceOfTransient;
802   std::list<Handle(GEOM_Object)>::iterator it = thePoints.begin();
803   for (; it != thePoints.end(); it++) {
804     Handle(GEOM_Function) aRefPnt = (*it)->GetLastFunction();
805     if (aRefPnt.IsNull()) {
806       return NULL;
807     }
808     aPoints->Append(aRefPnt);
809   }
810   aCI.SetPoints(aPoints);
811
812   aCI.SetIsClosed(theIsClosed);
813   aCI.SetDoReordering(theDoReordering);
814
815   //Compute the Spline value
816   try {
817     OCC_CATCH_SIGNALS;
818     if (!GetSolver()->ComputeFunction(aFunction)) {
819       SetErrorCode("Spline driver failed");
820       return NULL;
821     }
822   }
823   catch (Standard_Failure) {
824     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
825     SetErrorCode(aFail->GetMessageString());
826     return NULL;
827   }
828
829   //Make a Python command
830   GEOM::TPythonDump pd (aFunction);
831   pd << aSpline << " = geompy.MakeInterpol([";
832
833   it = thePoints.begin();
834   pd << (*it++);
835   while (it != thePoints.end()) {
836     pd << ", " << (*it++);
837   }
838   pd << "], " << theIsClosed << ", " << theDoReordering << ")";
839
840   SetErrorCode(OK);
841   return aSpline;
842 }
843
844
845 //=============================================================================
846 /*!
847  *  MakeSplineInterpolWithTangents
848  */
849 //=============================================================================
850 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeSplineInterpolWithTangents
851                                           (std::list<Handle(GEOM_Object)> thePoints,
852                                            Handle(GEOM_Object) theFirstVec,
853                                            Handle(GEOM_Object) theLastVec)
854 {
855   SetErrorCode(KO);
856
857   //Add a new Spline object
858   Handle(GEOM_Object) aSpline = GetEngine()->AddObject(GetDocID(), GEOM_SPLINE);
859
860   //Add a new Spline function for interpolation type
861   Handle(GEOM_Function) aFunction =
862     aSpline->AddFunction(GEOMImpl_SplineDriver::GetID(), SPLINE_INTERPOL_TANGENTS);
863   if (aFunction.IsNull()) return NULL;
864
865   //Check if the function is set correctly
866   if (aFunction->GetDriverGUID() != GEOMImpl_SplineDriver::GetID()) return NULL;
867
868   GEOMImpl_ISpline aCI (aFunction);
869
870   aCI.SetConstructorType(POINT_CONSTRUCTOR);
871
872   Handle(TColStd_HSequenceOfTransient) aPoints = new TColStd_HSequenceOfTransient;
873   std::list<Handle(GEOM_Object)>::iterator it = thePoints.begin();
874   for (; it != thePoints.end(); it++) {
875     Handle(GEOM_Function) aRefPnt = (*it)->GetLastFunction();
876     if (aRefPnt.IsNull()) {
877       SetErrorCode("NULL point for Interpolation");
878       return NULL;
879     }
880     aPoints->Append(aRefPnt);
881   }
882   aCI.SetPoints(aPoints);
883
884   Handle(GEOM_Function) aVec1 = theFirstVec->GetLastFunction();
885   Handle(GEOM_Function) aVec2 = theLastVec->GetLastFunction();
886
887   if (aVec1.IsNull() || aVec2.IsNull()) return NULL;
888
889   aCI.SetFirstVector(aVec1);
890   aCI.SetLastVector(aVec2);
891
892   //Compute the Spline value
893   try {
894     OCC_CATCH_SIGNALS;
895     if (!GetSolver()->ComputeFunction(aFunction)) {
896       SetErrorCode("Spline driver failed");
897       return NULL;
898     }
899   }
900   catch (Standard_Failure) {
901     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
902     SetErrorCode(aFail->GetMessageString());
903     return NULL;
904   }
905
906   //Make a Python command
907   GEOM::TPythonDump pd (aFunction);
908   pd << aSpline << " = geompy.MakeInterpolWithTangents([";
909
910   it = thePoints.begin();
911   pd << (*it++);
912   while (it != thePoints.end()) {
913     pd << ", " << (*it++);
914   }
915   pd << "], " << theFirstVec << ", " << theLastVec << ")";
916
917   SetErrorCode(OK);
918   return aSpline;
919 }
920
921 //=============================================================================
922 /*!
923  *  MakeCurveParametric
924  */
925 //=============================================================================
926 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeCurveParametric
927              (const char* thexExpr, const char* theyExpr, const char* thezExpr,
928               double theParamMin, double theParamMax, double theParamStep,
929               CurveType theCurveType,
930               int theParamNbStep, bool theNewMethod)
931 {
932   TCollection_AsciiString aPyScript;
933   aPyScript +="from math import *                                          \n";
934   aPyScript +="def X(t):                                                   \n";
935   aPyScript +="    return ";
936   aPyScript += thexExpr;
937   aPyScript += "\n";
938   aPyScript +="def Y(t):                                                   \n";
939   aPyScript +="    return ";
940   aPyScript += theyExpr;
941   aPyScript += "\n";
942
943   aPyScript +="def Z(t):                                                   \n";
944   aPyScript +="    return ";
945   aPyScript += thezExpr;
946   aPyScript += "\n";
947
948   if (theNewMethod)
949   {
950     aPyScript +="def coordCalculator(tmin, tmax, nstep):                     \n";
951     aPyScript +="   coords = []                                              \n";
952     aPyScript +="   tstep  = (tmax - tmin) / nstep                           \n";
953     aPyScript +="   n = 0                                                    \n";
954     aPyScript +="   while n <= nstep :                                       \n";
955     aPyScript +="      t = tmin + n*tstep                                    \n";
956     aPyScript +="      coords.append([X(t), Y(t), Z(t)])                     \n";
957     aPyScript +="      n = n+1                                               \n";
958     aPyScript +="   return coords                                            \n";
959   }
960   else
961   {
962     aPyScript +="def coordCalculator(tmin, tmax, tstep):                      \n";
963     aPyScript +="   coords = []                                              \n";
964     aPyScript +="   while tmin <= tmax :                                     \n";
965     aPyScript +="      coords.append([X(tmin), Y(tmin), Z(tmin)])            \n";
966     aPyScript +="      tmin = tmin + tstep                                   \n";
967     aPyScript +="   return coords                                            \n";
968   }
969
970   SetErrorCode(KO);
971
972   if(theParamMin >= theParamMax) {
973     SetErrorCode("The minimum value of the parameter must be less than maximum value !!!");
974     return NULL;
975   }
976
977   if(!theNewMethod && theParamStep <= 0.0) {
978     SetErrorCode("Value of the step must be positive !!!");
979     return NULL;
980   }
981   else if(theNewMethod && theParamNbStep < 0) {
982     SetErrorCode("The number of steps must be positive !!!");
983     return NULL;
984   }
985
986   /* Initialize the Python interpreter */
987   if (! Py_IsInitialized()) {
988     SetErrorCode("Python interpreter is not initialized !!! ");
989     return NULL;
990   }
991
992   PyGILState_STATE gstate;
993   gstate = PyGILState_Ensure();
994
995   PyObject* main_mod = PyImport_AddModule("__main__");
996   PyObject* main_dict = PyModule_GetDict(main_mod);
997
998   PyObject* obj = PyRun_String(aPyScript.ToCString(), Py_file_input, main_dict, NULL);
999
1000   if (obj == NULL) {
1001     SetErrorCode("Error during executing of python script !!!");
1002     PyErr_Print();
1003     PyGILState_Release(gstate);
1004     return NULL;
1005   } else {
1006     Py_DECREF(obj);
1007   }
1008
1009   PyObject * func = NULL;
1010   func = PyObject_GetAttrString(main_mod, "coordCalculator");
1011  
1012   if (func == NULL){
1013     SetErrorCode("Can't get function from python module !!!");
1014     PyGILState_Release(gstate);
1015     return NULL;
1016   }
1017
1018   PyObject* coords;
1019   if (theNewMethod)
1020     coords = PyObject_CallFunction(func,(char*)"(d, d, i)", theParamMin, theParamMax, theParamNbStep );
1021   else
1022     coords = PyObject_CallFunction(func,(char*)"(d, d, d)", theParamMin, theParamMax, theParamStep );
1023
1024   if (coords == NULL){
1025     fflush(stderr);
1026     std::string err_description="";
1027     PyObject* new_stderr = newPyStdOut(err_description);
1028     PyObject* old_stderr = PySys_GetObject((char*)"stderr");
1029     Py_INCREF(old_stderr);
1030     PySys_SetObject((char*)"stderr", new_stderr);
1031     PyErr_Print();
1032     PySys_SetObject((char*)"stderr", old_stderr);
1033     Py_DECREF(new_stderr);
1034     MESSAGE("Can't evaluate coordCalculator()" << " error is " << err_description);
1035     SetErrorCode("Can't evaluate the expressions, please check them !!!");
1036     PyGILState_Release(gstate);
1037     return NULL;
1038   }
1039
1040   int lsize = PyList_Size( coords );
1041
1042   if(lsize <= 0) {
1043     SetErrorCode("Empty list of the points, please check input parameters !!!");
1044     return NULL;
1045   }
1046
1047   Handle(TColStd_HArray1OfReal) aCoordsArray = new TColStd_HArray1OfReal (1, lsize * 3);
1048
1049   int k=1;
1050   for ( Py_ssize_t i = 0; i < lsize; ++i ) {
1051     PyObject* coord = PyList_GetItem( coords, i );
1052     if (coord != NULL) {
1053       for ( Py_ssize_t j = 0; j < PyList_Size(coord); ++j) {
1054         PyObject* item = PyList_GetItem(coord, j);
1055         aCoordsArray->SetValue(k, PyFloat_AsDouble(item));
1056         k++;
1057       }
1058     }
1059   }
1060
1061   Py_DECREF(coords);
1062
1063   PyGILState_Release(gstate);
1064
1065   Handle(GEOM_Object) aCurve;
1066   Handle(GEOM_Function) aFunction;
1067   TCollection_AsciiString aCurveType;
1068
1069   switch(theCurveType) {
1070   case Polyline: {
1071     //Add a new Polyline object
1072     aCurve = GetEngine()->AddObject(GetDocID(), GEOM_POLYLINE);
1073
1074     //Add a new Polyline function for creation a polyline relatively to points set
1075     aFunction = aCurve->AddFunction(GEOMImpl_PolylineDriver::GetID(), POLYLINE_POINTS);
1076     if (aFunction.IsNull()) return NULL;
1077
1078     //Check if the function is set correctly
1079     if (aFunction->GetDriverGUID() != GEOMImpl_PolylineDriver::GetID()) return NULL;
1080
1081     GEOMImpl_IPolyline aCI (aFunction);
1082
1083     aCI.SetLength(lsize);
1084     aCI.SetConstructorType(COORD_CONSTRUCTOR);
1085     aCI.SetIsClosed(false);
1086     aCI.SetCoordinates(aCoordsArray);
1087     aCurveType = "GEOM.Polyline";
1088     break;
1089   }
1090   case Bezier: {
1091     //Add a new Spline object
1092     aCurve = GetEngine()->AddObject(GetDocID(), GEOM_SPLINE);
1093     //Add a new Spline function for creation a bezier curve relatively to points set
1094     aFunction =
1095       aCurve->AddFunction(GEOMImpl_SplineDriver::GetID(), SPLINE_BEZIER);
1096     if (aFunction.IsNull()) return NULL;
1097
1098     //Check if the function is set correctly
1099     if (aFunction->GetDriverGUID() != GEOMImpl_SplineDriver::GetID()) return NULL;
1100
1101     GEOMImpl_ISpline aCI (aFunction);
1102
1103     aCI.SetConstructorType(COORD_CONSTRUCTOR);
1104     aCI.SetIsClosed(false);
1105     aCI.SetCoordinates(aCoordsArray);
1106     aCurveType = "GEOM.Bezier";
1107     break;
1108   }
1109   case Interpolation: {
1110     //Add a new Spline object
1111     aCurve = GetEngine()->AddObject(GetDocID(), GEOM_SPLINE);
1112
1113     //Add a new Spline function for creation a bezier curve relatively to points set
1114     aFunction = aCurve->AddFunction(GEOMImpl_SplineDriver::GetID(), SPLINE_INTERPOLATION);
1115     if (aFunction.IsNull()) return NULL;
1116
1117     //Check if the function is set correctly
1118     if (aFunction->GetDriverGUID() != GEOMImpl_SplineDriver::GetID()) return NULL;
1119
1120     GEOMImpl_ISpline aCI (aFunction);
1121     aCI.SetConstructorType(COORD_CONSTRUCTOR);
1122     aCI.SetIsClosed(false);
1123     aCI.SetDoReordering(false);
1124     aCI.SetCoordinates(aCoordsArray);
1125     aCurveType = "GEOM.Interpolation";
1126     break;
1127   }
1128   }
1129
1130   GEOMImpl_ICurveParametric aIP(aFunction);
1131   aIP.SetExprX      (thexExpr);
1132   aIP.SetExprY      (theyExpr);
1133   aIP.SetExprZ      (thezExpr);
1134   aIP.SetParamMin   (theParamMin);
1135   aIP.SetParamMax   (theParamMax);
1136   if ( theNewMethod )
1137     aIP.SetParamNbStep(theParamNbStep);
1138   else
1139     aIP.SetParamStep  (theParamStep);
1140
1141   //Compute the Curve value
1142   try {
1143     OCC_CATCH_SIGNALS;
1144     if (!GetSolver()->ComputeFunction(aFunction)) {
1145       SetErrorCode("Curve driver failed !!!");
1146       return NULL;
1147     }
1148   }
1149   catch (Standard_Failure) {
1150     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1151     SetErrorCode(aFail->GetMessageString());
1152     return NULL;
1153   }
1154
1155   //Make a Python command
1156   GEOM::TPythonDump pd (aFunction);
1157   pd << aCurve << " = geompy.MakeCurveParametric(";
1158   pd << "\"" << thexExpr << "\", ";
1159   pd << "\"" << theyExpr << "\", ";
1160   pd << "\"" << thezExpr << "\", ";
1161
1162   pd << theParamMin <<", ";
1163   pd << theParamMax <<", ";
1164   if (theNewMethod)
1165     pd << theParamNbStep <<", ";
1166   else
1167     pd << theParamStep <<", ";
1168   pd << aCurveType.ToCString() <<", ";
1169   pd << theNewMethod <<")";
1170
1171   SetErrorCode(OK);
1172   return aCurve;
1173 }
1174
1175 //=============================================================================
1176 /*!
1177  *  MakeSketcher
1178  */
1179 //=============================================================================
1180 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeSketcher (const char* theCommand,
1181                                                               std::list<double> theWorkingPlane)
1182 {
1183   SetErrorCode(KO);
1184
1185   if (!theCommand || strcmp(theCommand, "") == 0) return NULL;
1186
1187   //Add a new Sketcher object
1188   Handle(GEOM_Object) aSketcher = GetEngine()->AddObject(GetDocID(), GEOM_SKETCHER);
1189
1190   //Add a new Sketcher function
1191   Handle(GEOM_Function) aFunction =
1192     aSketcher->AddFunction(GEOMImpl_SketcherDriver::GetID(), SKETCHER_NINE_DOUBLS);
1193   if (aFunction.IsNull()) return NULL;
1194
1195   //Check if the function is set correctly
1196   if (aFunction->GetDriverGUID() != GEOMImpl_SketcherDriver::GetID()) return NULL;
1197
1198   GEOMImpl_ISketcher aCI (aFunction);
1199
1200   TCollection_AsciiString aCommand((char*) theCommand);
1201   aCI.SetCommand(aCommand);
1202
1203   int ind = 1;
1204   std::list<double>::iterator it = theWorkingPlane.begin();
1205   for (; it != theWorkingPlane.end(); it++, ind++)
1206     aCI.SetWorkingPlane(ind, *it);
1207
1208   //Compute the Sketcher value
1209   try {
1210     OCC_CATCH_SIGNALS;
1211     if (!GetSolver()->ComputeFunction(aFunction)) {
1212       SetErrorCode("Sketcher driver failed");
1213       return NULL;
1214     }
1215   }
1216   catch (Standard_Failure) {
1217     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1218     SetErrorCode(aFail->GetMessageString());
1219     return NULL;
1220   }
1221
1222   //Make a Python command
1223   GEOM::TPythonDump pd (aFunction);
1224   pd << aSketcher << " = geompy.MakeSketcher(\"" << aCommand.ToCString() << "\", [";
1225
1226   it = theWorkingPlane.begin();
1227   pd << (*it++);
1228   while (it != theWorkingPlane.end()) {
1229     pd << ", " << (*it++);
1230   }
1231   pd << "])";
1232
1233   SetErrorCode(OK);
1234   return aSketcher;
1235 }
1236
1237 //=============================================================================
1238 /*!
1239  *  MakeSketcherOnPlane
1240  */
1241 //=============================================================================
1242 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeSketcherOnPlane
1243                                (const char* theCommand,
1244                                 Handle(GEOM_Object)            theWorkingPlane)
1245 {
1246   SetErrorCode(KO);
1247
1248   if (!theCommand || strcmp(theCommand, "") == 0) return NULL;
1249
1250   //Add a new Sketcher object
1251   Handle(GEOM_Object) aSketcher = GetEngine()->AddObject(GetDocID(), GEOM_SKETCHER);
1252
1253   //Add a new Sketcher function
1254   Handle(GEOM_Function) aFunction =
1255     aSketcher->AddFunction(GEOMImpl_SketcherDriver::GetID(), SKETCHER_PLANE);
1256   if (aFunction.IsNull()) return NULL;
1257
1258   //Check if the function is set correctly
1259   if (aFunction->GetDriverGUID() != GEOMImpl_SketcherDriver::GetID()) return NULL;
1260
1261   GEOMImpl_ISketcher aCI (aFunction);
1262
1263   TCollection_AsciiString aCommand((char*) theCommand);
1264   aCI.SetCommand(aCommand);
1265
1266   Handle(GEOM_Function) aRefPlane = theWorkingPlane->GetLastFunction();
1267   if (aRefPlane.IsNull()) return NULL;
1268   aCI.SetWorkingPlane( aRefPlane );
1269
1270   //Compute the Sketcher value
1271   try {
1272     OCC_CATCH_SIGNALS;
1273     if (!GetSolver()->ComputeFunction(aFunction)) {
1274       SetErrorCode("Sketcher 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) << aSketcher << " = geompy.MakeSketcherOnPlane(\""
1286     << aCommand.ToCString() << "\", " << theWorkingPlane << " )";
1287
1288   SetErrorCode(OK);
1289   return aSketcher;
1290 }
1291
1292 //=============================================================================
1293 /*!
1294  *  Make3DSketcherCommand
1295  */
1296 //=============================================================================
1297 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::Make3DSketcherCommand (const char* theCommand)
1298 {
1299   SetErrorCode(KO);
1300
1301   if (!theCommand || strcmp(theCommand, "") == 0) return NULL;
1302
1303   //Add a new Sketcher object
1304   Handle(GEOM_Object) aSketcher = GetEngine()->AddObject(GetDocID(), GEOM_3DSKETCHER);
1305
1306   //Add a new Sketcher function
1307   Handle(GEOM_Function) aFunction =
1308     aSketcher->AddFunction(GEOMImpl_3DSketcherDriver::GetID(), SKETCHER3D_COMMAND);
1309   if (aFunction.IsNull()) return NULL;
1310
1311   //Check if the function is set correctly
1312   if (aFunction->GetDriverGUID() != GEOMImpl_3DSketcherDriver::GetID()) return NULL;
1313
1314   GEOMImpl_I3DSketcher aCI (aFunction);
1315
1316   TCollection_AsciiString aCommand ((char*) theCommand);
1317   aCI.SetCommand(aCommand);
1318
1319   //Compute the 3D Sketcher value
1320   try {
1321     OCC_CATCH_SIGNALS;
1322     if (!GetSolver()->ComputeFunction(aFunction)) {
1323       SetErrorCode("3D Sketcher driver failed");
1324       return NULL;
1325     }
1326   }
1327   catch (Standard_Failure) {
1328     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1329     SetErrorCode(aFail->GetMessageString());
1330     return NULL;
1331   }
1332
1333   //Make a Python command
1334   GEOM::TPythonDump pd (aFunction);
1335   pd << aSketcher << " = geompy.Make3DSketcherCommand(\"" << aCommand.ToCString() << "\")";
1336
1337   SetErrorCode(OK);
1338   return aSketcher;
1339 }
1340
1341 //=============================================================================
1342 /*!
1343  *  Make3DSketcher
1344  */
1345 //=============================================================================
1346 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::Make3DSketcher (std::list<double> theCoordinates)
1347 {
1348   SetErrorCode(KO);
1349
1350   //Add a new Sketcher object
1351   Handle(GEOM_Object) a3DSketcher = GetEngine()->AddObject(GetDocID(), GEOM_3DSKETCHER);
1352
1353   //Add a new Sketcher function
1354   Handle(GEOM_Function) aFunction =
1355     a3DSketcher->AddFunction(GEOMImpl_3DSketcherDriver::GetID(), SKETCHER3D_COORDS);
1356   if (aFunction.IsNull()) return NULL;
1357
1358   //Check if the function is set correctly
1359   if (aFunction->GetDriverGUID() != GEOMImpl_3DSketcherDriver::GetID()) return NULL;
1360
1361   GEOMImpl_I3DSketcher aCI (aFunction);
1362
1363   int nbOfCoords = 0;
1364   std::list<double>::iterator it = theCoordinates.begin();
1365   for (; it != theCoordinates.end(); it++)
1366     nbOfCoords++;
1367
1368   Handle(TColStd_HArray1OfReal) aCoordsArray = new TColStd_HArray1OfReal (1, nbOfCoords);
1369
1370   it = theCoordinates.begin();
1371   int ind = 1;
1372   for (; it != theCoordinates.end(); it++, ind++)
1373     aCoordsArray->SetValue(ind, *it);
1374
1375   aCI.SetCoordinates(aCoordsArray);
1376
1377   //Compute the Sketcher value
1378   try {
1379     OCC_CATCH_SIGNALS;
1380     if (!GetSolver()->ComputeFunction(aFunction)) {
1381       SetErrorCode("3D Sketcher driver failed");
1382       return NULL;
1383     }
1384   }
1385   catch (Standard_Failure) {
1386     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1387     SetErrorCode(aFail->GetMessageString());
1388     return NULL;
1389   }
1390
1391   //Make a Python command
1392   GEOM::TPythonDump pd (aFunction);
1393   pd << a3DSketcher << " = geompy.Make3DSketcher([";
1394
1395   it = theCoordinates.begin();
1396   pd << (*it++);
1397   while (it != theCoordinates.end()) {
1398     pd << ", " << (*it++);
1399   }
1400   pd << "])";
1401
1402   SetErrorCode(OK);
1403   return a3DSketcher;
1404 }
1405
1406 //=============================================================================
1407 /*!
1408  *  MakeIsoline
1409  */
1410 //=============================================================================
1411 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeIsoline
1412                   (const Handle(GEOM_Object) &theFace,
1413                    const bool                 IsUIso,
1414                    const double               theParameter)
1415 {
1416   SetErrorCode(KO);
1417
1418   if (theFace.IsNull()) {
1419     return NULL;
1420   }
1421
1422   //Add a new Spline object
1423   Handle(GEOM_Object) anIsoline =
1424     GetEngine()->AddObject(GetDocID(), GEOM_ISOLINE);
1425
1426   //Add a new Spline function for interpolation type
1427   Handle(GEOM_Function) aFunction =
1428     anIsoline->AddFunction(GEOMImpl_ShapeDriver::GetID(), SHAPE_ISOLINE);
1429
1430   if (aFunction.IsNull()) {
1431     return NULL;
1432   }
1433
1434   //Check if the function is set correctly
1435   if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) {
1436     return NULL;
1437   }
1438
1439   GEOMImpl_IIsoline     aCI (aFunction);
1440   Handle(GEOM_Function) aRefFace = theFace->GetLastFunction();
1441
1442   if (aRefFace.IsNull()) {
1443     return NULL;
1444   }
1445
1446   aCI.SetFace(aRefFace);
1447   aCI.SetIsUIso(IsUIso);
1448   aCI.SetParameter(theParameter);
1449
1450   //Compute the isoline curve
1451   try {
1452     OCC_CATCH_SIGNALS;
1453     if (!GetSolver()->ComputeFunction(aFunction)) {
1454       SetErrorCode("Shape driver failed");
1455       return NULL;
1456     }
1457   }
1458   catch (Standard_Failure) {
1459     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1460     SetErrorCode(aFail->GetMessageString());
1461     return NULL;
1462   }
1463
1464   //Make a Python command
1465   GEOM::TPythonDump (aFunction) << anIsoline << " = geompy.MakeIsoline( "
1466     << theFace << ", " << IsUIso << ", " << theParameter << " )";
1467
1468   SetErrorCode(OK);
1469   return anIsoline;
1470 }
1471
1472 //=============================================================================
1473 /*!
1474  *  MakePolyline2D
1475  */
1476 //=============================================================================
1477 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakePolyline2D
1478             (const std::list <std::list <double> >         &theCoords,
1479              const Handle(TColStd_HArray1OfExtendedString) &theNames,
1480              const Handle(TColStd_HArray1OfByte)           &theTypes,
1481              const Handle(TColStd_HArray1OfByte)           &theCloseds,
1482              const Handle(TColStd_HArray1OfReal)           &theWorkingPlane)
1483 {
1484   SetErrorCode(KO);
1485
1486   if (theCoords.empty()   || theNames.IsNull() || theTypes.IsNull() ||
1487       theCloseds.IsNull() || theWorkingPlane.IsNull()) {
1488     return NULL;
1489   }
1490
1491   // Add a new Polyline object
1492   Handle(GEOM_Object)   aResult   =
1493     GetEngine()->AddObject(GetDocID(), GEOM_POLYLINE2D);
1494   Handle(GEOM_Function) aFunction = aResult->AddFunction
1495     (GEOMImpl_PolylineDriver::GetID(), POLYLINE2D_PLN_COORDS);
1496
1497   if (aFunction.IsNull()) {
1498     return NULL;
1499   }
1500
1501   // Check if the function is set correctly
1502   if (aFunction->GetDriverGUID() != GEOMImpl_PolylineDriver::GetID()) {
1503     return NULL;
1504   }
1505
1506   GEOMImpl_IPolyline2D aCI(aFunction);
1507
1508   aCI.SetCoords(theCoords);
1509   aCI.SetNames(theNames);
1510   aCI.SetTypes(theTypes);
1511   aCI.SetClosedFlags(theCloseds);
1512   aCI.SetWorkingPlaneDbls(theWorkingPlane);
1513
1514   // Compute the isoline curve
1515   try {
1516 #if OCC_VERSION_LARGE > 0x06010000
1517     OCC_CATCH_SIGNALS;
1518 #endif
1519     if (!GetSolver()->ComputeFunction(aFunction)) {
1520       SetErrorCode("Polyline driver failed");
1521       return NULL;
1522     }
1523   }
1524   catch (Standard_Failure) {
1525     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1526     SetErrorCode(aFail->GetMessageString());
1527     return NULL;
1528   }
1529
1530   //Make a Python command
1531   GEOMImpl_PolylineDumper aDumper(theCoords, theNames, theTypes,
1532                                   theCloseds, theWorkingPlane);
1533
1534   aDumper.Dump(aResult);
1535
1536   if (aDumper.IsDone() == Standard_False) {
1537     SetErrorCode("Python dump failed");
1538     return NULL;
1539   }
1540
1541   SetErrorCode(OK);
1542   return aResult;
1543 }
1544
1545 //=============================================================================
1546 /*!
1547  *  MakePolyline2DOnPlane
1548  */
1549 //=============================================================================
1550 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakePolyline2DOnPlane
1551             (const std::list <std::list <double> >         &theCoords,
1552              const Handle(TColStd_HArray1OfExtendedString) &theNames,
1553              const Handle(TColStd_HArray1OfByte)           &theTypes,
1554              const Handle(TColStd_HArray1OfByte)           &theCloseds,
1555              const Handle(GEOM_Object)                     &theWorkingPlane)
1556 {
1557   SetErrorCode(KO);
1558
1559   if (theCoords.empty()   || theNames.IsNull() || theTypes.IsNull() ||
1560       theCloseds.IsNull() || theWorkingPlane.IsNull()) {
1561     return NULL;
1562   }
1563
1564   //Add a new Polyline object
1565   Handle(GEOM_Object) aResult =
1566     GetEngine()->AddObject(GetDocID(), GEOM_POLYLINE2D);
1567   Handle(GEOM_Function) aFunction = aResult->AddFunction
1568     (GEOMImpl_PolylineDriver::GetID(), POLYLINE2D_PLN_OBJECT);
1569
1570   if (aFunction.IsNull()) {
1571     return NULL;
1572   }
1573
1574   //Check if the function is set correctly
1575   if (aFunction->GetDriverGUID() != GEOMImpl_PolylineDriver::GetID()) {
1576     return NULL;
1577   }
1578
1579   Handle(GEOM_Function) aRefPlane = theWorkingPlane->GetLastFunction();
1580
1581   if (aRefPlane.IsNull()) {
1582     return NULL;
1583   }
1584
1585   GEOMImpl_IPolyline2D aCI(aFunction);
1586
1587   aCI.SetCoords(theCoords);
1588   aCI.SetNames(theNames);
1589   aCI.SetTypes(theTypes);
1590   aCI.SetClosedFlags(theCloseds);
1591   aCI.SetWorkingPlane(aRefPlane);
1592
1593   //Compute the isoline curve
1594   try {
1595 #if OCC_VERSION_LARGE > 0x06010000
1596     OCC_CATCH_SIGNALS;
1597 #endif
1598     if (!GetSolver()->ComputeFunction(aFunction)) {
1599       SetErrorCode("Polyline driver failed");
1600       return NULL;
1601     }
1602   }
1603   catch (Standard_Failure) {
1604     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1605     SetErrorCode(aFail->GetMessageString());
1606     return NULL;
1607   }
1608
1609   //Make a Python command
1610   GEOMImpl_PolylineDumper aDumper(theCoords, theNames, theTypes,
1611                                   theCloseds, theWorkingPlane);
1612
1613   aDumper.Dump(aResult);
1614
1615   if (aDumper.IsDone() == Standard_False) {
1616     SetErrorCode("Python dump failed");
1617     return NULL;
1618   }
1619
1620   SetErrorCode(OK);
1621   return aResult;
1622 }