FreeCAD

1
/***************************************************************************
2
 *   Copyright (c) 2016 Werner Mayer <wmayer[at]users.sourceforge.net>     *
3
 *                                                                         *
4
 *   This file is part of the FreeCAD CAx development system.              *
5
 *                                                                         *
6
 *   This library is free software; you can redistribute it and/or         *
7
 *   modify it under the terms of the GNU Library General Public           *
8
 *   License as published by the Free Software Foundation; either          *
9
 *   version 2 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         *
14
 *   GNU Library General Public License for more details.                  *
15
 *                                                                         *
16
 *   You should have received a copy of the GNU Library General Public     *
17
 *   License along with this library; see the file COPYING.LIB. If not,    *
18
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
19
 *   Suite 330, Boston, MA  02111-1307, USA                                *
20
 *                                                                         *
21
 ***************************************************************************/
22

23
#include "PreCompiled.h"
24
#ifndef _PreComp_
25
# include <Geom2d_BezierCurve.hxx>
26
# include <gp_Pnt2d.hxx>
27
# include <TColgp_Array1OfPnt2d.hxx>
28
# include <TColStd_Array1OfReal.hxx>
29
#endif
30

31
#include <Base/GeometryPyCXX.h>
32

33
#include "Geom2d/BezierCurve2dPy.h"
34
#include "Geom2d/BezierCurve2dPy.cpp"
35
#include "OCCError.h"
36

37

38
using namespace Part;
39

40
// returns a string which represents the object e.g. when printed in python
41
std::string BezierCurve2dPy::representation() const
42
{
43
    return "<BezierCurve2d object>";
44
}
45

46
PyObject *BezierCurve2dPy::PyMake(struct _typeobject *, PyObject *, PyObject *)  // Python wrapper
47
{
48
    // create a new instance of BezierCurve2dPy and the Twin object
49
    return new BezierCurve2dPy(new Geom2dBezierCurve);
50
}
51

52
// constructor method
53
int BezierCurve2dPy::PyInit(PyObject* /*args*/, PyObject* /*kwd*/)
54
{
55
    return 0;
56
}
57

58
PyObject* BezierCurve2dPy::isRational(PyObject *args)
59
{
60
    if (!PyArg_ParseTuple(args, ""))
61
        return nullptr;
62
    Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
63
        (getGeometry2dPtr()->handle());
64
    Standard_Boolean val = curve->IsRational();
65
    return PyBool_FromLong(val ? 1 : 0);
66
}
67

68
PyObject* BezierCurve2dPy::isPeriodic(PyObject *args)
69
{
70
    if (!PyArg_ParseTuple(args, ""))
71
        return nullptr;
72
    Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
73
        (getGeometry2dPtr()->handle());
74
    Standard_Boolean val = curve->IsPeriodic();
75
    return PyBool_FromLong(val ? 1 : 0);
76
}
77

78
PyObject* BezierCurve2dPy::isClosed(PyObject *args)
79
{
80
    if (!PyArg_ParseTuple(args, ""))
81
        return nullptr;
82
    Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
83
        (getGeometry2dPtr()->handle());
84
    Standard_Boolean val = curve->IsClosed();
85
    return PyBool_FromLong(val ? 1 : 0);
86
}
87

88
PyObject* BezierCurve2dPy::increase(PyObject * args)
89
{
90
    int degree;
91
    if (!PyArg_ParseTuple(args, "i", &degree))
92
        return nullptr;
93
    Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
94
        (getGeometry2dPtr()->handle());
95
    curve->Increase(degree);
96
    Py_Return;
97
}
98

99
PyObject* BezierCurve2dPy::insertPoleAfter(PyObject * args)
100
{
101
    int index;
102
    double weight=1.0;
103
    PyObject* p;
104
    if (!PyArg_ParseTuple(args, "iO!|d", &index, Base::Vector2dPy::type_object(), &p, &weight))
105
        return nullptr;
106
    Base::Vector2d vec = Py::toVector2d(p);
107
    gp_Pnt2d pnt(vec.x, vec.y);
108
    try {
109
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
110
            (getGeometry2dPtr()->handle());
111
        curve->InsertPoleAfter(index,pnt,weight);
112
        Py_Return;
113
    }
114
    catch (Standard_Failure& e) {
115
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
116
        return nullptr;
117
    }
118
}
119

120
PyObject* BezierCurve2dPy::insertPoleBefore(PyObject * args)
121
{
122
    int index;
123
    double weight=1.0;
124
    PyObject* p;
125
    if (!PyArg_ParseTuple(args, "iO!|d", &index, Base::Vector2dPy::type_object(), &p, &weight))
126
        return nullptr;
127
    Base::Vector2d vec = Py::toVector2d(p);
128
    gp_Pnt2d pnt(vec.x, vec.y);
129
    try {
130
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
131
            (getGeometry2dPtr()->handle());
132
        curve->InsertPoleBefore(index,pnt,weight);
133
        Py_Return;
134
    }
135
    catch (Standard_Failure& e) {
136
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
137
        return nullptr;
138
    }
139
}
140

141
PyObject* BezierCurve2dPy::removePole(PyObject * args)
142
{
143
    int index;
144
    if (!PyArg_ParseTuple(args, "i", &index))
145
        return nullptr;
146
    try {
147
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
148
            (getGeometry2dPtr()->handle());
149
        curve->RemovePole(index);
150
        Py_Return;
151
    }
152
    catch (Standard_Failure& e) {
153
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
154
        return nullptr;
155
    }
156
}
157

158
PyObject* BezierCurve2dPy::segment(PyObject * args)
159
{
160
    double u1,u2;
161
    if (!PyArg_ParseTuple(args, "dd", &u1,&u2))
162
        return nullptr;
163
    try {
164
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
165
            (getGeometry2dPtr()->handle());
166
        curve->Segment(u1,u2);
167
        Py_Return;
168
    }
169
    catch (Standard_Failure& e) {
170
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
171
        return nullptr;
172
    }
173
}
174

175
PyObject* BezierCurve2dPy::setPole(PyObject * args)
176
{
177
    int index;
178
    double weight=-1.0;
179
    PyObject* p;
180
    if (!PyArg_ParseTuple(args, "iO!|d", &index, Base::Vector2dPy::type_object(), &p, &weight))
181
        return nullptr;
182
    Base::Vector2d vec = Py::toVector2d(p);
183
    gp_Pnt2d pnt(vec.x, vec.y);
184
    try {
185
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
186
            (getGeometry2dPtr()->handle());
187
        if (weight < 0.0)
188
            curve->SetPole(index,pnt);
189
        else
190
            curve->SetPole(index,pnt,weight);
191
        Py_Return;
192
    }
193
    catch (Standard_Failure& e) {
194
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
195
        return nullptr;
196
    }
197
}
198

199
PyObject* BezierCurve2dPy::getPole(PyObject * args)
200
{
201
    int index;
202
    if (!PyArg_ParseTuple(args, "i", &index))
203
        return nullptr;
204
    try {
205
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
206
            (getGeometry2dPtr()->handle());
207
        Standard_OutOfRange_Raise_if
208
            (index < 1 || index > curve->NbPoles(), "Pole index out of range");
209
        gp_Pnt2d pnt = curve->Pole(index);
210
        return Py::new_reference_to(Base::Vector2dPy::create(pnt.X(), pnt.Y()));
211
    }
212
    catch (Standard_Failure& e) {
213
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
214
        return nullptr;
215
    }
216
}
217

218
PyObject* BezierCurve2dPy::getPoles(PyObject * args)
219
{
220
    if (!PyArg_ParseTuple(args, ""))
221
        return nullptr;
222
    try {
223
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
224
            (getGeometry2dPtr()->handle());
225
        TColgp_Array1OfPnt2d p(1,curve->NbPoles());
226
        curve->Poles(p);
227
        Py::List poles;
228

229
        for (Standard_Integer i=p.Lower(); i<=p.Upper(); i++) {
230
            gp_Pnt2d pnt = p(i);
231
            poles.append(Base::Vector2dPy::create(pnt.X(), pnt.Y()));
232
        }
233
        return Py::new_reference_to(poles);
234
    }
235
    catch (Standard_Failure& e) {
236
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
237
        return nullptr;
238
    }
239
}
240

241
PyObject* BezierCurve2dPy::setPoles(PyObject * args)
242
{
243
    PyObject* plist;
244
    if (!PyArg_ParseTuple(args, "O", &plist))
245
        return nullptr;
246
    try {
247
        Py::Sequence list(plist);
248
        TColgp_Array1OfPnt2d poles(1,list.size());
249
        int index = poles.Lower();
250
        for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
251
            Base::Vector2d pole = Py::toVector2d(*it);
252
            poles.SetValue(index++, gp_Pnt2d(pole.x,pole.y));
253
        }
254

255
        Handle(Geom2d_BezierCurve) bezier = new Geom2d_BezierCurve(poles);
256
        this->getGeom2dBezierCurvePtr()->setHandle(bezier);
257
        Py_Return;
258
    }
259
    catch (Standard_Failure& e) {
260
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
261
        return nullptr;
262
    }
263
}
264

265
PyObject* BezierCurve2dPy::setWeight(PyObject * args)
266
{
267
    int index;
268
    double weight;
269
    if (!PyArg_ParseTuple(args, "id", &index,&weight))
270
        return nullptr;
271
    try {
272
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
273
            (getGeometry2dPtr()->handle());
274
        curve->SetWeight(index,weight);
275
        Py_Return;
276
    }
277
    catch (Standard_Failure& e) {
278
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
279
        return nullptr;
280
    }
281
}
282

283
PyObject* BezierCurve2dPy::getWeight(PyObject * args)
284
{
285
    int index;
286
    if (!PyArg_ParseTuple(args, "i", &index))
287
        return nullptr;
288
    try {
289
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
290
            (getGeometry2dPtr()->handle());
291
        Standard_OutOfRange_Raise_if
292
            (index < 1 || index > curve->NbPoles() , "Weight index out of range");
293
        double weight = curve->Weight(index);
294
        return Py_BuildValue("d", weight);
295
    }
296
    catch (Standard_Failure& e) {
297
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
298
        return nullptr;
299
    }
300
}
301

302
PyObject* BezierCurve2dPy::getWeights(PyObject * args)
303
{
304
    if (!PyArg_ParseTuple(args, ""))
305
        return nullptr;
306
    try {
307
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
308
            (getGeometry2dPtr()->handle());
309
        TColStd_Array1OfReal w(1,curve->NbPoles());
310
        curve->Weights(w);
311
        Py::List weights;
312
        for (Standard_Integer i=w.Lower(); i<=w.Upper(); i++) {
313
            weights.append(Py::Float(w(i)));
314
        }
315
        return Py::new_reference_to(weights);
316
    }
317
    catch (Standard_Failure& e) {
318
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
319
        return nullptr;
320
    }
321
}
322

323
PyObject* BezierCurve2dPy::getResolution(PyObject* args)
324
{
325
    double tol;
326
    if (!PyArg_ParseTuple(args, "d", &tol))
327
        return nullptr;
328
    try {
329
        Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
330
            (getGeometry2dPtr()->handle());
331
        double utol;
332
        curve->Resolution(tol,utol);
333
        return Py_BuildValue("d",utol);
334
    }
335
    catch (Standard_Failure& e) {
336
        PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
337
        return nullptr;
338
    }
339
}
340
Py::Long BezierCurve2dPy::getDegree() const
341
{
342
    Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
343
        (getGeometry2dPtr()->handle());
344
    return Py::Long(curve->Degree());
345
}
346

347
Py::Long BezierCurve2dPy::getMaxDegree() const
348
{
349
    Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
350
        (getGeometry2dPtr()->handle());
351
    return Py::Long(curve->MaxDegree());
352
}
353

354
Py::Long BezierCurve2dPy::getNbPoles() const
355
{
356
    Handle(Geom2d_BezierCurve) curve = Handle(Geom2d_BezierCurve)::DownCast
357
        (getGeometry2dPtr()->handle());
358
    return Py::Long(curve->NbPoles());
359
}
360

361
Py::Object BezierCurve2dPy::getStartPoint() const
362
{
363
    Handle(Geom2d_BezierCurve) c = Handle(Geom2d_BezierCurve)::DownCast
364
        (getGeometry2dPtr()->handle());
365
    gp_Pnt2d pnt = c->StartPoint();
366
    return Base::Vector2dPy::create(pnt.X(), pnt.Y());
367
}
368

369
Py::Object BezierCurve2dPy::getEndPoint() const
370
{
371
    Handle(Geom2d_BezierCurve) c = Handle(Geom2d_BezierCurve)::DownCast
372
        (getGeometry2dPtr()->handle());
373
    gp_Pnt2d pnt = c->EndPoint();
374
    return Base::Vector2dPy::create(pnt.X(), pnt.Y());
375
}
376

377
PyObject *BezierCurve2dPy::getCustomAttributes(const char* /*attr*/) const
378
{
379
    return nullptr;
380
}
381

382
int BezierCurve2dPy::setCustomAttributes(const char* /*attr*/, PyObject* /*obj*/)
383
{
384
    return 0;
385
}
386