1 // Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
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>
32 #include <structmember.h>
38 #include "GEOMImpl_ICurvesOperations.hxx"
39 #include "GEOMImpl_Types.hxx"
41 #include "GEOM_Function.hxx"
42 #include "GEOM_PythonDump.hxx"
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_SketcherDriver.hxx"
50 #include "GEOMImpl_3DSketcherDriver.hxx"
52 #include "GEOMImpl_IPolyline.hxx"
53 #include "GEOMImpl_ICircle.hxx"
54 #include "GEOMImpl_ISpline.hxx"
55 #include "GEOMImpl_IEllipse.hxx"
56 #include "GEOMImpl_IArc.hxx"
57 #include "GEOMImpl_ISketcher.hxx"
58 #include "GEOMImpl_I3DSketcher.hxx"
59 #include "GEOMImpl_ICurveParametric.hxx"
61 #include <Basics_OCCTVersion.hxx>
63 #include "utilities.h"
65 #include <TDF_Tool.hxx>
66 #include <TColStd_HArray1OfReal.hxx>
68 #include <Standard_Failure.hxx>
69 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
72 /* ==================================
73 * =========== PYTHON ==============
74 * ==================================*/
83 PyStdOut_dealloc(PyStdOut *self)
89 PyStdOut_write(PyStdOut *self, PyObject *args)
93 if (!PyArg_ParseTuple(args, "t#:write",&c, &l))
97 *(self->out)=*(self->out)+c;
103 static PyMethodDef PyStdOut_methods[] = {
104 {"write", (PyCFunction)PyStdOut_write, METH_VARARGS,
105 PyDoc_STR("write(string) -> None")},
106 {NULL, NULL} /* sentinel */
109 static PyMemberDef PyStdOut_memberlist[] = {
110 {(char*)"softspace", T_INT, offsetof(PyStdOut, softspace), 0,
111 (char*)"flag indicating that a space needs to be printed; used by print"},
112 {NULL} /* Sentinel */
115 static PyTypeObject PyStdOut_Type = {
116 /* The ob_type field must be initialized in the module init function
117 * to be portable to Windows without using C++. */
118 PyObject_HEAD_INIT(NULL)
121 sizeof(PyStdOut), /*tp_basicsize*/
124 (destructor)PyStdOut_dealloc, /*tp_dealloc*/
131 0, /*tp_as_sequence*/
136 PyObject_GenericGetAttr, /*tp_getattro*/
137 /* softspace is writable: we must supply tp_setattro */
138 PyObject_GenericSetAttr, /* tp_setattro */
140 Py_TPFLAGS_DEFAULT, /*tp_flags*/
144 0, /*tp_richcompare*/
145 0, /*tp_weaklistoffset*/
148 PyStdOut_methods, /*tp_methods*/
149 PyStdOut_memberlist, /*tp_members*/
163 PyObject * newPyStdOut( std::string& out )
166 self = PyObject_New(PyStdOut, &PyStdOut_Type);
171 return (PyObject*)self;
175 ////////////////////////END PYTHON///////////////////////////
176 //=============================================================================
180 //=============================================================================
181 GEOMImpl_ICurvesOperations::GEOMImpl_ICurvesOperations (GEOM_Engine* theEngine, int theDocID)
182 : GEOM_IOperations(theEngine, theDocID)
184 MESSAGE("GEOMImpl_ICurvesOperations::GEOMImpl_ICurvesOperations");
187 //=============================================================================
191 //=============================================================================
192 GEOMImpl_ICurvesOperations::~GEOMImpl_ICurvesOperations()
194 MESSAGE("GEOMImpl_ICurvesOperations::~GEOMImpl_ICurvesOperations");
198 //=============================================================================
202 //=============================================================================
203 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeCircleThreePnt (Handle(GEOM_Object) thePnt1,
204 Handle(GEOM_Object) thePnt2,
205 Handle(GEOM_Object) thePnt3)
209 if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
211 //Add a new Circle object
212 Handle(GEOM_Object) aCircle = GetEngine()->AddObject(GetDocID(), GEOM_CIRCLE);
214 //Add a new Circle function for creation a circle relatively to three points
215 Handle(GEOM_Function) aFunction =
216 aCircle->AddFunction(GEOMImpl_CircleDriver::GetID(), CIRCLE_THREE_PNT);
217 if (aFunction.IsNull()) return NULL;
219 //Check if the function is set correctly
220 if (aFunction->GetDriverGUID() != GEOMImpl_CircleDriver::GetID()) return NULL;
222 GEOMImpl_ICircle aCI (aFunction);
224 Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
225 Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
226 Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
228 if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
230 aCI.SetPoint1(aRefPnt1);
231 aCI.SetPoint2(aRefPnt2);
232 aCI.SetPoint3(aRefPnt3);
234 //Compute the Circle value
236 #if OCC_VERSION_LARGE > 0x06010000
239 if (!GetSolver()->ComputeFunction(aFunction)) {
240 SetErrorCode("Circle driver failed");
244 catch (Standard_Failure) {
245 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
246 SetErrorCode(aFail->GetMessageString());
250 //Make a Python command
251 GEOM::TPythonDump(aFunction) << aCircle << " = geompy.MakeCircleThreePnt("
252 << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << ")";
258 //=============================================================================
260 * MakeCircleCenter2Pnt
262 //=============================================================================
263 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeCircleCenter2Pnt (Handle(GEOM_Object) thePnt1,
264 Handle(GEOM_Object) thePnt2,
265 Handle(GEOM_Object) thePnt3)
269 if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
271 //Add a new Circle object
272 Handle(GEOM_Object) aCircle = GetEngine()->AddObject(GetDocID(), GEOM_CIRCLE);
274 //Add a new Circle function for creation a circle relatively to center and 2 points
275 Handle(GEOM_Function) aFunction =
276 aCircle->AddFunction(GEOMImpl_CircleDriver::GetID(), CIRCLE_CENTER_TWO_PNT);
277 if (aFunction.IsNull()) return NULL;
279 //Check if the function is set correctly
280 if (aFunction->GetDriverGUID() != GEOMImpl_CircleDriver::GetID()) return NULL;
282 GEOMImpl_ICircle aCI (aFunction);
284 Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
285 Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
286 Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
288 if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
290 aCI.SetPoint1(aRefPnt1);
291 aCI.SetPoint2(aRefPnt2);
292 aCI.SetPoint3(aRefPnt3);
294 //Compute the Circle value
296 #if OCC_VERSION_LARGE > 0x06010000
299 if (!GetSolver()->ComputeFunction(aFunction)) {
300 SetErrorCode("Circle driver failed");
304 catch (Standard_Failure) {
305 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
306 SetErrorCode(aFail->GetMessageString());
310 //Make a Python command
311 GEOM::TPythonDump(aFunction) << aCircle << " = geompy.MakeCircleCenter2Pnt("
312 << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << ")";
318 //=============================================================================
322 //=============================================================================
323 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeCirclePntVecR
324 (Handle(GEOM_Object) thePnt, Handle(GEOM_Object) theVec, double theR)
328 // Not set thePnt means origin of global CS,
329 // Not set theVec means Z axis of global CS
330 //if (thePnt.IsNull() || theVec.IsNull()) return NULL;
332 //Add a new Circle object
333 Handle(GEOM_Object) aCircle = GetEngine()->AddObject(GetDocID(), GEOM_CIRCLE);
335 //Add a new Circle function for creation a circle relatively to point and vector
336 Handle(GEOM_Function) aFunction =
337 aCircle->AddFunction(GEOMImpl_CircleDriver::GetID(), CIRCLE_PNT_VEC_R);
338 if (aFunction.IsNull()) return NULL;
340 //Check if the function is set correctly
341 if (aFunction->GetDriverGUID() != GEOMImpl_CircleDriver::GetID()) return NULL;
343 GEOMImpl_ICircle aCI (aFunction);
345 if (!thePnt.IsNull()) {
346 Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
347 if (aRefPnt.IsNull()) return NULL;
348 aCI.SetCenter(aRefPnt);
351 if (!theVec.IsNull()) {
352 Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
353 if (aRefVec.IsNull()) return NULL;
354 aCI.SetVector(aRefVec);
359 //Compute the Circle value
361 #if OCC_VERSION_LARGE > 0x06010000
364 if (!GetSolver()->ComputeFunction(aFunction)) {
365 SetErrorCode("Circle driver failed");
369 catch (Standard_Failure) {
370 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
371 SetErrorCode(aFail->GetMessageString());
375 //Make a Python command
376 GEOM::TPythonDump(aFunction) << aCircle << " = geompy.MakeCircle("
377 << thePnt << ", " << theVec << ", " << theR << ")";
383 //=============================================================================
387 //=============================================================================
388 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeEllipse
389 (Handle(GEOM_Object) thePnt, Handle(GEOM_Object) theVec,
390 double theRMajor, double theRMinor,
391 Handle(GEOM_Object) theVecMaj)
395 // Not set thePnt means origin of global CS,
396 // Not set theVec means Z axis of global CS
397 // Not set theVecMaj means X axis of global CS
398 //if (thePnt.IsNull() || theVec.IsNull()) return NULL;
400 //Add a new Ellipse object
401 Handle(GEOM_Object) anEll = GetEngine()->AddObject(GetDocID(), GEOM_ELLIPSE);
403 //Add a new Ellipse function
404 Handle(GEOM_Function) aFunction =
405 anEll->AddFunction(GEOMImpl_EllipseDriver::GetID(), ELLIPSE_PNT_VEC_RR);
406 if (aFunction.IsNull()) return NULL;
408 //Check if the function is set correctly
409 if (aFunction->GetDriverGUID() != GEOMImpl_EllipseDriver::GetID()) return NULL;
411 GEOMImpl_IEllipse aCI (aFunction);
413 if (!thePnt.IsNull()) {
414 Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
415 if (aRefPnt.IsNull()) return NULL;
416 aCI.SetCenter(aRefPnt);
419 if (!theVec.IsNull()) {
420 Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
421 if (aRefVec.IsNull()) return NULL;
422 aCI.SetVector(aRefVec);
425 aCI.SetRMajor(theRMajor);
426 aCI.SetRMinor(theRMinor);
428 if (!theVecMaj.IsNull()) {
429 Handle(GEOM_Function) aRefVecMaj = theVecMaj->GetLastFunction();
430 if (aRefVecMaj.IsNull()) return NULL;
431 aCI.SetVectorMajor(aRefVecMaj);
434 //Compute the Ellipse value
436 #if OCC_VERSION_LARGE > 0x06010000
439 if (!GetSolver()->ComputeFunction(aFunction)) {
440 SetErrorCode("Ellipse driver failed");
444 catch (Standard_Failure) {
445 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
446 SetErrorCode(aFail->GetMessageString());
450 //Make a Python command
451 if (!theVecMaj.IsNull()) {
452 GEOM::TPythonDump(aFunction) << anEll << " = geompy.MakeEllipse("
453 << thePnt << ", " << theVec << ", " << theRMajor << ", " << theRMinor
454 << ", " << theVecMaj << ")";
457 GEOM::TPythonDump(aFunction) << anEll << " = geompy.MakeEllipse("
458 << thePnt << ", " << theVec << ", " << theRMajor << ", " << theRMinor << ")";
465 //=============================================================================
469 //=============================================================================
470 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeArc (Handle(GEOM_Object) thePnt1,
471 Handle(GEOM_Object) thePnt2,
472 Handle(GEOM_Object) thePnt3)
476 if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
478 //Add a new Circle Arc object
479 Handle(GEOM_Object) anArc = GetEngine()->AddObject(GetDocID(), GEOM_CIRC_ARC);
481 //Add a new Circle Arc function
482 Handle(GEOM_Function) aFunction =
483 anArc->AddFunction(GEOMImpl_ArcDriver::GetID(), CIRC_ARC_THREE_PNT);
485 if (aFunction.IsNull()) return NULL;
487 //Check if the function is set correctly
488 if (aFunction->GetDriverGUID() != GEOMImpl_ArcDriver::GetID()) return NULL;
489 GEOMImpl_IArc aCI (aFunction);
491 Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
492 Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
493 Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
495 if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
497 aCI.SetPoint1(aRefPnt1);
498 aCI.SetPoint2(aRefPnt2);
499 aCI.SetPoint3(aRefPnt3);
501 //Compute the Arc value
503 #if OCC_VERSION_LARGE > 0x06010000
506 if (!GetSolver()->ComputeFunction(aFunction)) {
507 SetErrorCode("Arc driver failed");
511 catch (Standard_Failure) {
512 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
513 SetErrorCode(aFail->GetMessageString());
517 //Make a Python command
518 GEOM::TPythonDump(aFunction) << anArc << " = geompy.MakeArc("
519 << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << ")";
525 //=============================================================================
529 //=============================================================================
530 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeArcCenter (Handle(GEOM_Object) thePnt1,
531 Handle(GEOM_Object) thePnt2,
532 Handle(GEOM_Object) thePnt3,
536 if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
538 //Add a new Circle Arc object
539 Handle(GEOM_Object) anArc = GetEngine()->AddObject(GetDocID(), GEOM_CIRC_ARC);
541 //Add a new Circle Arc function
542 Handle(GEOM_Function) aFunction =
543 anArc->AddFunction(GEOMImpl_ArcDriver::GetID(), CIRC_ARC_CENTER);
544 if (aFunction.IsNull()) return NULL;
546 //Check if the function is set correctly
547 if (aFunction->GetDriverGUID() != GEOMImpl_ArcDriver::GetID()) return NULL;
549 GEOMImpl_IArc aCI (aFunction);
551 Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
552 Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
553 Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
555 if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
557 aCI.SetPoint1(aRefPnt1);
558 aCI.SetPoint2(aRefPnt2);
559 aCI.SetPoint3(aRefPnt3);
560 aCI.SetSense(theSense);
562 //Compute the Arc value
564 #if OCC_VERSION_LARGE > 0x06010000
567 if (!GetSolver()->ComputeFunction(aFunction)) {
568 SetErrorCode("Arc driver failed");
572 catch (Standard_Failure) {
573 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
574 SetErrorCode(aFail->GetMessageString());
577 //Make a Python command
578 GEOM::TPythonDump(aFunction) << anArc << " = geompy.MakeArcCenter("
579 << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << "," << theSense << ")";
585 //=============================================================================
589 //=============================================================================
590 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeArcOfEllipse (Handle(GEOM_Object) thePnt1,
591 Handle(GEOM_Object) thePnt2,
592 Handle(GEOM_Object) thePnt3)
596 if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
598 //Add a new Circle Arc object
599 Handle(GEOM_Object) anArc = GetEngine()->AddObject(GetDocID(), GEOM_ELLIPSE_ARC);
601 //Add a new Circle Arc function
602 Handle(GEOM_Function) aFunction =
603 anArc->AddFunction(GEOMImpl_ArcDriver::GetID(), ELLIPSE_ARC_CENTER_TWO_PNT);
605 if (aFunction.IsNull()) return NULL;
607 //Check if the function is set correctly
608 if (aFunction->GetDriverGUID() != GEOMImpl_ArcDriver::GetID()) return NULL;
609 GEOMImpl_IArc aCI (aFunction);
611 Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
612 Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
613 Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
615 if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
617 aCI.SetPoint1(aRefPnt1);
618 aCI.SetPoint2(aRefPnt2);
619 aCI.SetPoint3(aRefPnt3);
621 //Compute the Arc value
623 #if OCC_VERSION_LARGE > 0x06010000
626 if (!GetSolver()->ComputeFunction(aFunction)) {
627 SetErrorCode("Arc driver failed");
631 catch (Standard_Failure) {
632 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
633 SetErrorCode(aFail->GetMessageString());
637 //Make a Python command
638 GEOM::TPythonDump(aFunction) << anArc << " = geompy.MakeArcOfEllipse("
639 << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << ")";
645 //=============================================================================
649 //=============================================================================
650 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakePolyline (std::list<Handle(GEOM_Object)> thePoints,
655 //Add a new Polyline object
656 Handle(GEOM_Object) aPolyline = GetEngine()->AddObject(GetDocID(), GEOM_POLYLINE);
658 //Add a new Polyline function for creation a polyline relatively to points set
659 Handle(GEOM_Function) aFunction =
660 aPolyline->AddFunction(GEOMImpl_PolylineDriver::GetID(), POLYLINE_POINTS);
661 if (aFunction.IsNull()) return NULL;
663 //Check if the function is set correctly
664 if (aFunction->GetDriverGUID() != GEOMImpl_PolylineDriver::GetID()) return NULL;
666 GEOMImpl_IPolyline aCI (aFunction);
668 int aLen = thePoints.size();
670 aCI.SetConstructorType(POINT_CONSTRUCTOR);
673 std::list<Handle(GEOM_Object)>::iterator it = thePoints.begin();
674 for (; it != thePoints.end(); it++, ind++) {
675 Handle(GEOM_Function) aRefPnt = (*it)->GetLastFunction();
676 if (aRefPnt.IsNull()) {
677 SetErrorCode("NULL point for Polyline");
680 aCI.SetPoint(ind, aRefPnt);
683 aCI.SetIsClosed(theIsClosed);
685 //Compute the Polyline value
687 #if OCC_VERSION_LARGE > 0x06010000
690 if (!GetSolver()->ComputeFunction(aFunction)) {
691 SetErrorCode("Polyline driver failed");
695 catch (Standard_Failure) {
696 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
697 SetErrorCode(aFail->GetMessageString());
701 //Make a Python command
702 GEOM::TPythonDump pd (aFunction);
703 pd << aPolyline << " = geompy.MakePolyline([";
705 it = thePoints.begin();
707 while (it != thePoints.end()) {
708 pd << ", " << (*it++);
710 pd << "], " << theIsClosed << ")";
716 //=============================================================================
720 //=============================================================================
721 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeSplineBezier
722 (std::list<Handle(GEOM_Object)> thePoints,
727 //Add a new Spline object
728 Handle(GEOM_Object) aSpline = GetEngine()->AddObject(GetDocID(), GEOM_SPLINE);
730 //Add a new Spline function for creation a bezier curve relatively to points set
731 Handle(GEOM_Function) aFunction =
732 aSpline->AddFunction(GEOMImpl_SplineDriver::GetID(), SPLINE_BEZIER);
733 if (aFunction.IsNull()) return NULL;
735 //Check if the function is set correctly
736 if (aFunction->GetDriverGUID() != GEOMImpl_SplineDriver::GetID()) return NULL;
738 GEOMImpl_ISpline aCI (aFunction);
740 aCI.SetConstructorType(POINT_CONSTRUCTOR);
742 Handle(TColStd_HSequenceOfTransient) aPoints = new TColStd_HSequenceOfTransient;
743 std::list<Handle(GEOM_Object)>::iterator it = thePoints.begin();
744 for (; it != thePoints.end(); it++) {
745 Handle(GEOM_Function) aRefPnt = (*it)->GetLastFunction();
746 if (aRefPnt.IsNull()) {
747 SetErrorCode("NULL point for Besier curve");
750 aPoints->Append(aRefPnt);
752 aCI.SetPoints(aPoints);
754 aCI.SetIsClosed(theIsClosed);
756 //Compute the Spline value
758 #if OCC_VERSION_LARGE > 0x06010000
761 if (!GetSolver()->ComputeFunction(aFunction)) {
762 SetErrorCode("Spline driver failed");
766 catch (Standard_Failure) {
767 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
768 SetErrorCode(aFail->GetMessageString());
772 //Make a Python command
773 GEOM::TPythonDump pd (aFunction);
774 pd << aSpline << " = geompy.MakeBezier([";
776 it = thePoints.begin();
778 while (it != thePoints.end()) {
779 pd << ", " << (*it++);
781 pd << "], " << theIsClosed << ")";
787 //=============================================================================
789 * MakeSplineInterpolation
791 //=============================================================================
792 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeSplineInterpolation
793 (std::list<Handle(GEOM_Object)> thePoints,
795 bool theDoReordering)
799 //Add a new Spline object
800 Handle(GEOM_Object) aSpline = GetEngine()->AddObject(GetDocID(), GEOM_SPLINE);
802 //Add a new Spline function for interpolation type
803 Handle(GEOM_Function) aFunction =
804 aSpline->AddFunction(GEOMImpl_SplineDriver::GetID(), SPLINE_INTERPOLATION);
805 if (aFunction.IsNull()) return NULL;
807 //Check if the function is set correctly
808 if (aFunction->GetDriverGUID() != GEOMImpl_SplineDriver::GetID()) return NULL;
810 GEOMImpl_ISpline aCI (aFunction);
812 aCI.SetConstructorType(POINT_CONSTRUCTOR);
814 Handle(TColStd_HSequenceOfTransient) aPoints = new TColStd_HSequenceOfTransient;
815 std::list<Handle(GEOM_Object)>::iterator it = thePoints.begin();
816 for (; it != thePoints.end(); it++) {
817 Handle(GEOM_Function) aRefPnt = (*it)->GetLastFunction();
818 if (aRefPnt.IsNull()) {
821 aPoints->Append(aRefPnt);
823 aCI.SetPoints(aPoints);
825 aCI.SetIsClosed(theIsClosed);
826 aCI.SetDoReordering(theDoReordering);
828 //Compute the Spline value
830 #if OCC_VERSION_LARGE > 0x06010000
833 if (!GetSolver()->ComputeFunction(aFunction)) {
834 SetErrorCode("Spline driver failed");
838 catch (Standard_Failure) {
839 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
840 SetErrorCode(aFail->GetMessageString());
844 //Make a Python command
845 GEOM::TPythonDump pd (aFunction);
846 pd << aSpline << " = geompy.MakeInterpol([";
848 it = thePoints.begin();
850 while (it != thePoints.end()) {
851 pd << ", " << (*it++);
853 pd << "], " << theIsClosed << ", " << theDoReordering << ")";
860 //=============================================================================
862 * MakeSplineInterpolWithTangents
864 //=============================================================================
865 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeSplineInterpolWithTangents
866 (std::list<Handle(GEOM_Object)> thePoints,
867 Handle(GEOM_Object) theFirstVec,
868 Handle(GEOM_Object) theLastVec)
872 //Add a new Spline object
873 Handle(GEOM_Object) aSpline = GetEngine()->AddObject(GetDocID(), GEOM_SPLINE);
875 //Add a new Spline function for interpolation type
876 Handle(GEOM_Function) aFunction =
877 aSpline->AddFunction(GEOMImpl_SplineDriver::GetID(), SPLINE_INTERPOL_TANGENTS);
878 if (aFunction.IsNull()) return NULL;
880 //Check if the function is set correctly
881 if (aFunction->GetDriverGUID() != GEOMImpl_SplineDriver::GetID()) return NULL;
883 GEOMImpl_ISpline aCI (aFunction);
885 aCI.SetConstructorType(POINT_CONSTRUCTOR);
887 Handle(TColStd_HSequenceOfTransient) aPoints = new TColStd_HSequenceOfTransient;
888 std::list<Handle(GEOM_Object)>::iterator it = thePoints.begin();
889 for (; it != thePoints.end(); it++) {
890 Handle(GEOM_Function) aRefPnt = (*it)->GetLastFunction();
891 if (aRefPnt.IsNull()) {
892 SetErrorCode("NULL point for Interpolation");
895 aPoints->Append(aRefPnt);
897 aCI.SetPoints(aPoints);
899 Handle(GEOM_Function) aVec1 = theFirstVec->GetLastFunction();
900 Handle(GEOM_Function) aVec2 = theLastVec->GetLastFunction();
902 if (aVec1.IsNull() || aVec2.IsNull()) return NULL;
904 aCI.SetFirstVector(aVec1);
905 aCI.SetLastVector(aVec2);
907 //Compute the Spline value
909 #if OCC_VERSION_LARGE > 0x06010000
912 if (!GetSolver()->ComputeFunction(aFunction)) {
913 SetErrorCode("Spline driver failed");
917 catch (Standard_Failure) {
918 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
919 SetErrorCode(aFail->GetMessageString());
923 //Make a Python command
924 GEOM::TPythonDump pd (aFunction);
925 pd << aSpline << " = geompy.MakeInterpolWithTangents([";
927 it = thePoints.begin();
929 while (it != thePoints.end()) {
930 pd << ", " << (*it++);
932 pd << "], " << theFirstVec << ", " << theLastVec << ")";
938 //=============================================================================
940 * MakeCurveParametric
942 //=============================================================================
943 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeCurveParametric
944 (const char* thexExpr, const char* theyExpr, const char* thezExpr,
945 double theParamMin, double theParamMax, double theParamStep,
946 CurveType theCurveType,
947 int theParamNbStep, bool theNewMethod)
949 TCollection_AsciiString aPyScript;
950 aPyScript +="from math import * \n";
951 aPyScript +="def X(t): \n";
952 aPyScript +=" return ";
953 aPyScript += thexExpr;
955 aPyScript +="def Y(t): \n";
956 aPyScript +=" return ";
957 aPyScript += theyExpr;
960 aPyScript +="def Z(t): \n";
961 aPyScript +=" return ";
962 aPyScript += thezExpr;
967 aPyScript +="def coordCalculator(tmin, tmax, nstep): \n";
968 aPyScript +=" coords = [] \n";
969 aPyScript +=" tstep = (tmax - tmin) / nstep \n";
970 aPyScript +=" n = 0 \n";
971 aPyScript +=" while n <= nstep : \n";
972 aPyScript +=" t = tmin + n*tstep \n";
973 aPyScript +=" coords.append([X(t), Y(t), Z(t)]) \n";
974 aPyScript +=" n = n+1 \n";
975 aPyScript +=" return coords \n";
979 aPyScript +="def coordCalculator(tmin, tmax, tstep): \n";
980 aPyScript +=" coords = [] \n";
981 aPyScript +=" while tmin <= tmax : \n";
982 aPyScript +=" coords.append([X(tmin), Y(tmin), Z(tmin)]) \n";
983 aPyScript +=" tmin = tmin + tstep \n";
984 aPyScript +=" return coords \n";
989 if(theParamMin >= theParamMax) {
990 SetErrorCode("The minimum value of the parameter must be less than maximum value !!!");
994 if(!theNewMethod && theParamStep <= 0.0) {
995 SetErrorCode("Value of the step must be positive !!!");
998 else if(theNewMethod && theParamNbStep < 0) {
999 SetErrorCode("The number of steps must be positive !!!");
1003 /* Initialize the Python interpreter */
1004 if (! Py_IsInitialized()) {
1005 SetErrorCode("Python interpreter is not initialized !!! ");
1009 PyGILState_STATE gstate;
1010 gstate = PyGILState_Ensure();
1012 PyObject* main_mod = PyImport_AddModule("__main__");
1013 PyObject* main_dict = PyModule_GetDict(main_mod);
1015 PyObject* obj = PyRun_String(aPyScript.ToCString(), Py_file_input, main_dict, NULL);
1018 SetErrorCode("Error during executing of python script !!!");
1020 PyGILState_Release(gstate);
1026 PyObject * func = NULL;
1027 func = PyObject_GetAttrString(main_mod, "coordCalculator");
1030 SetErrorCode("Can't get function from python module !!!");
1031 PyGILState_Release(gstate);
1037 coords = PyObject_CallFunction(func,(char*)"(d, d, i)", theParamMin, theParamMax, theParamNbStep );
1039 coords = PyObject_CallFunction(func,(char*)"(d, d, d)", theParamMin, theParamMax, theParamStep );
1041 PyObject* new_stderr = NULL;
1043 if (coords == NULL){
1045 std::string err_description="";
1046 new_stderr = newPyStdOut(err_description);
1047 PySys_SetObject((char*)"stderr", new_stderr);
1049 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1050 Py_DECREF(new_stderr);
1051 MESSAGE("Can't evaluate coordCalculator()" << " error is " << err_description);
1052 SetErrorCode("Can't evaluate the expressions, please check them !!!");
1053 PyGILState_Release(gstate);
1057 int lsize = PyList_Size( coords );
1060 SetErrorCode("Empty list of the points, please check input parameters !!!");
1064 Handle(TColStd_HArray1OfReal) aCoordsArray = new TColStd_HArray1OfReal (1, lsize * 3);
1067 for ( Py_ssize_t i = 0; i < lsize; ++i ) {
1068 PyObject* coord = PyList_GetItem( coords, i );
1069 if (coord != NULL) {
1070 for ( Py_ssize_t j = 0; j < PyList_Size(coord); ++j) {
1071 PyObject* item = PyList_GetItem(coord, j);
1072 aCoordsArray->SetValue(k, PyFloat_AsDouble(item));
1080 PyGILState_Release(gstate);
1082 Handle(GEOM_Object) aCurve;
1083 Handle(GEOM_Function) aFunction;
1084 TCollection_AsciiString aCurveType;
1086 switch(theCurveType) {
1088 //Add a new Polyline object
1089 aCurve = GetEngine()->AddObject(GetDocID(), GEOM_POLYLINE);
1091 //Add a new Polyline function for creation a polyline relatively to points set
1092 aFunction = aCurve->AddFunction(GEOMImpl_PolylineDriver::GetID(), POLYLINE_POINTS);
1093 if (aFunction.IsNull()) return NULL;
1095 //Check if the function is set correctly
1096 if (aFunction->GetDriverGUID() != GEOMImpl_PolylineDriver::GetID()) return NULL;
1098 GEOMImpl_IPolyline aCI (aFunction);
1100 aCI.SetLength(lsize);
1101 aCI.SetConstructorType(COORD_CONSTRUCTOR);
1102 aCI.SetIsClosed(false);
1103 aCI.SetCoordinates(aCoordsArray);
1104 aCurveType = "GEOM.Polyline";
1108 //Add a new Spline object
1109 aCurve = GetEngine()->AddObject(GetDocID(), GEOM_SPLINE);
1110 //Add a new Spline function for creation a bezier curve relatively to points set
1112 aCurve->AddFunction(GEOMImpl_SplineDriver::GetID(), SPLINE_BEZIER);
1113 if (aFunction.IsNull()) return NULL;
1115 //Check if the function is set correctly
1116 if (aFunction->GetDriverGUID() != GEOMImpl_SplineDriver::GetID()) return NULL;
1118 GEOMImpl_ISpline aCI (aFunction);
1120 aCI.SetConstructorType(COORD_CONSTRUCTOR);
1121 aCI.SetIsClosed(false);
1122 aCI.SetCoordinates(aCoordsArray);
1123 aCurveType = "GEOM.Bezier";
1126 case Interpolation: {
1127 //Add a new Spline object
1128 aCurve = GetEngine()->AddObject(GetDocID(), GEOM_SPLINE);
1130 //Add a new Spline function for creation a bezier curve relatively to points set
1131 aFunction = aCurve->AddFunction(GEOMImpl_SplineDriver::GetID(), SPLINE_INTERPOLATION);
1132 if (aFunction.IsNull()) return NULL;
1134 //Check if the function is set correctly
1135 if (aFunction->GetDriverGUID() != GEOMImpl_SplineDriver::GetID()) return NULL;
1137 GEOMImpl_ISpline aCI (aFunction);
1138 aCI.SetConstructorType(COORD_CONSTRUCTOR);
1139 aCI.SetIsClosed(false);
1140 aCI.SetDoReordering(false);
1141 aCI.SetCoordinates(aCoordsArray);
1142 aCurveType = "GEOM.Interpolation";
1147 GEOMImpl_ICurveParametric aIP(aFunction);
1148 aIP.SetExprX (thexExpr);
1149 aIP.SetExprY (theyExpr);
1150 aIP.SetExprZ (thezExpr);
1151 aIP.SetParamMin (theParamMin);
1152 aIP.SetParamMax (theParamMax);
1154 aIP.SetParamNbStep(theParamNbStep);
1156 aIP.SetParamStep (theParamStep);
1158 //Compute the Curve value
1160 #if OCC_VERSION_LARGE > 0x06010000
1163 if (!GetSolver()->ComputeFunction(aFunction)) {
1164 SetErrorCode("Curve driver failed !!!");
1168 catch (Standard_Failure) {
1169 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1170 SetErrorCode(aFail->GetMessageString());
1174 //Make a Python command
1175 GEOM::TPythonDump pd (aFunction);
1176 pd << aCurve << " = geompy.MakeCurveParametric(";
1177 pd << "\"" << thexExpr << "\", ";
1178 pd << "\"" << theyExpr << "\", ";
1179 pd << "\"" << thezExpr << "\", ";
1181 pd << theParamMin <<", ";
1182 pd << theParamMax <<", ";
1184 pd << theParamNbStep <<", ";
1186 pd << theParamStep <<", ";
1187 pd << aCurveType.ToCString() <<", ";
1188 pd << theNewMethod <<")";
1194 //=============================================================================
1198 //=============================================================================
1199 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeSketcher (const char* theCommand,
1200 std::list<double> theWorkingPlane)
1204 if (!theCommand || strcmp(theCommand, "") == 0) return NULL;
1206 //Add a new Sketcher object
1207 Handle(GEOM_Object) aSketcher = GetEngine()->AddObject(GetDocID(), GEOM_SKETCHER);
1209 //Add a new Sketcher function
1210 Handle(GEOM_Function) aFunction =
1211 aSketcher->AddFunction(GEOMImpl_SketcherDriver::GetID(), SKETCHER_NINE_DOUBLS);
1212 if (aFunction.IsNull()) return NULL;
1214 //Check if the function is set correctly
1215 if (aFunction->GetDriverGUID() != GEOMImpl_SketcherDriver::GetID()) return NULL;
1217 GEOMImpl_ISketcher aCI (aFunction);
1219 TCollection_AsciiString aCommand((char*) theCommand);
1220 aCI.SetCommand(aCommand);
1223 std::list<double>::iterator it = theWorkingPlane.begin();
1224 for (; it != theWorkingPlane.end(); it++, ind++)
1225 aCI.SetWorkingPlane(ind, *it);
1227 //Compute the Sketcher value
1229 #if OCC_VERSION_LARGE > 0x06010000
1232 if (!GetSolver()->ComputeFunction(aFunction)) {
1233 SetErrorCode("Sketcher driver failed");
1237 catch (Standard_Failure) {
1238 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1239 SetErrorCode(aFail->GetMessageString());
1243 //Make a Python command
1244 GEOM::TPythonDump pd (aFunction);
1245 pd << aSketcher << " = geompy.MakeSketcher(\"" << aCommand.ToCString() << "\", [";
1247 it = theWorkingPlane.begin();
1249 while (it != theWorkingPlane.end()) {
1250 pd << ", " << (*it++);
1258 //=============================================================================
1260 * MakeSketcherOnPlane
1262 //=============================================================================
1263 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::MakeSketcherOnPlane
1264 (const char* theCommand,
1265 Handle(GEOM_Object) theWorkingPlane)
1269 if (!theCommand || strcmp(theCommand, "") == 0) return NULL;
1271 //Add a new Sketcher object
1272 Handle(GEOM_Object) aSketcher = GetEngine()->AddObject(GetDocID(), GEOM_SKETCHER);
1274 //Add a new Sketcher function
1275 Handle(GEOM_Function) aFunction =
1276 aSketcher->AddFunction(GEOMImpl_SketcherDriver::GetID(), SKETCHER_PLANE);
1277 if (aFunction.IsNull()) return NULL;
1279 //Check if the function is set correctly
1280 if (aFunction->GetDriverGUID() != GEOMImpl_SketcherDriver::GetID()) return NULL;
1282 GEOMImpl_ISketcher aCI (aFunction);
1284 TCollection_AsciiString aCommand((char*) theCommand);
1285 aCI.SetCommand(aCommand);
1287 Handle(GEOM_Function) aRefPlane = theWorkingPlane->GetLastFunction();
1288 if (aRefPlane.IsNull()) return NULL;
1289 aCI.SetWorkingPlane( aRefPlane );
1291 //Compute the Sketcher value
1293 #if OCC_VERSION_LARGE > 0x06010000
1296 if (!GetSolver()->ComputeFunction(aFunction)) {
1297 SetErrorCode("Sketcher driver failed");
1301 catch (Standard_Failure) {
1302 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1303 SetErrorCode(aFail->GetMessageString());
1307 //Make a Python command
1308 GEOM::TPythonDump (aFunction) << aSketcher << " = geompy.MakeSketcherOnPlane(\""
1309 << aCommand.ToCString() << "\", " << theWorkingPlane << " )";
1315 //=============================================================================
1317 * Make3DSketcherCommand
1319 //=============================================================================
1320 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::Make3DSketcherCommand (const char* theCommand)
1324 if (!theCommand || strcmp(theCommand, "") == 0) return NULL;
1326 //Add a new Sketcher object
1327 Handle(GEOM_Object) aSketcher = GetEngine()->AddObject(GetDocID(), GEOM_3DSKETCHER);
1329 //Add a new Sketcher function
1330 Handle(GEOM_Function) aFunction =
1331 aSketcher->AddFunction(GEOMImpl_3DSketcherDriver::GetID(), SKETCHER3D_COMMAND);
1332 if (aFunction.IsNull()) return NULL;
1334 //Check if the function is set correctly
1335 if (aFunction->GetDriverGUID() != GEOMImpl_3DSketcherDriver::GetID()) return NULL;
1337 GEOMImpl_I3DSketcher aCI (aFunction);
1339 TCollection_AsciiString aCommand ((char*) theCommand);
1340 aCI.SetCommand(aCommand);
1342 //Compute the 3D Sketcher value
1344 #if OCC_VERSION_LARGE > 0x06010000
1347 if (!GetSolver()->ComputeFunction(aFunction)) {
1348 SetErrorCode("3D Sketcher driver failed");
1352 catch (Standard_Failure) {
1353 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1354 SetErrorCode(aFail->GetMessageString());
1358 //Make a Python command
1359 GEOM::TPythonDump pd (aFunction);
1360 pd << aSketcher << " = geompy.Make3DSketcherCommand(\"" << aCommand.ToCString() << "\")";
1366 //=============================================================================
1370 //=============================================================================
1371 Handle(GEOM_Object) GEOMImpl_ICurvesOperations::Make3DSketcher (std::list<double> theCoordinates)
1375 //Add a new Sketcher object
1376 Handle(GEOM_Object) a3DSketcher = GetEngine()->AddObject(GetDocID(), GEOM_3DSKETCHER);
1378 //Add a new Sketcher function
1379 Handle(GEOM_Function) aFunction =
1380 a3DSketcher->AddFunction(GEOMImpl_3DSketcherDriver::GetID(), SKETCHER3D_COORDS);
1381 if (aFunction.IsNull()) return NULL;
1383 //Check if the function is set correctly
1384 if (aFunction->GetDriverGUID() != GEOMImpl_3DSketcherDriver::GetID()) return NULL;
1386 GEOMImpl_I3DSketcher aCI (aFunction);
1389 std::list<double>::iterator it = theCoordinates.begin();
1390 for (; it != theCoordinates.end(); it++)
1393 Handle(TColStd_HArray1OfReal) aCoordsArray = new TColStd_HArray1OfReal (1, nbOfCoords);
1395 it = theCoordinates.begin();
1397 for (; it != theCoordinates.end(); it++, ind++)
1398 aCoordsArray->SetValue(ind, *it);
1400 aCI.SetCoordinates(aCoordsArray);
1402 //Compute the Sketcher value
1404 #if OCC_VERSION_LARGE > 0x06010000
1407 if (!GetSolver()->ComputeFunction(aFunction)) {
1408 SetErrorCode("3D Sketcher driver failed");
1412 catch (Standard_Failure) {
1413 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1414 SetErrorCode(aFail->GetMessageString());
1418 //Make a Python command
1419 GEOM::TPythonDump pd (aFunction);
1420 pd << a3DSketcher << " = geompy.Make3DSketcher([";
1422 it = theCoordinates.begin();
1424 while (it != theCoordinates.end()) {
1425 pd << ", " << (*it++);