← Back to branch summary

~ubuntu-branches/ubuntu/maverick/freecad/maverick

« back to all changes in this revision

Viewing changes to src/Mod/Part/App/BezierCurvePyImp.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Teemu Ikonen
  • Date: 2009-07-16 18:37:41 UTC
  • Revision ID: james.westby@ubuntu.com-20090716183741-oww9kcxqrk991i1n
Tags: upstream-0.8.2237
Import upstream version 0.8.2237

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Mod/Part/App/BezierCurvePyImp.cpp
 
1
/***************************************************************************
 
2
 *   Copyright (c) 2008 Werner Mayer <wmayer@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
 
 
24
#include "PreCompiled.h"
 
25
#ifndef _PreComp_
 
26
# include <Geom_BezierCurve.hxx>
 
27
# include <gp_Pnt.hxx>
 
28
# include <TColStd_Array1OfReal.hxx>
 
29
# include <TColgp_Array1OfPnt.hxx>
 
30
#endif
 
31
 
 
32
#include <Base/VectorPy.h>
 
33
#include <Base/GeometryPyCXX.h>
 
34
 
 
35
#include "Geometry.h"
 
36
#include "BezierCurvePy.h"
 
37
#include "BezierCurvePy.cpp"
 
38
 
 
39
using namespace Part;
 
40
 
 
41
// returns a string which represents the object e.g. when printed in python
 
42
const char *BezierCurvePy::representation(void) const
 
43
{
 
44
    return "<BezierCurve object>";
 
45
}
 
46
 
 
47
PyObject *BezierCurvePy::PyMake(struct _typeobject *, PyObject *, PyObject *)  // Python wrapper
 
48
{
 
49
    // create a new instance of BezierCurvePy and the Twin object 
 
50
    return new BezierCurvePy(new GeomBezierCurve);
 
51
}
 
52
 
 
53
// constructor method
 
54
int BezierCurvePy::PyInit(PyObject* /*args*/, PyObject* /*kwd*/)
 
55
{
 
56
    return 0;
 
57
}
 
58
 
 
59
PyObject* BezierCurvePy::isRational(PyObject *args)
 
60
{
 
61
    if (!PyArg_ParseTuple(args, ""))
 
62
        return 0;
 
63
    Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
64
        (getGeometryPtr()->handle());
 
65
    Standard_Boolean val = curve->IsRational();
 
66
    if (val) {
 
67
        Py_INCREF(Py_True);
 
68
        return Py_True;
 
69
    }
 
70
    else {
 
71
        Py_INCREF(Py_False);
 
72
        return Py_False;
 
73
    }
 
74
}
 
75
 
 
76
PyObject* BezierCurvePy::isPeriodic(PyObject *args)
 
77
{
 
78
    if (!PyArg_ParseTuple(args, ""))
 
79
        return 0;
 
80
    Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
81
        (getGeometryPtr()->handle());
 
82
    Standard_Boolean val = curve->IsPeriodic();
 
83
    if (val) {
 
84
        Py_INCREF(Py_True);
 
85
        return Py_True;
 
86
    }
 
87
    else {
 
88
        Py_INCREF(Py_False);
 
89
        return Py_False;
 
90
    }
 
91
}
 
92
 
 
93
PyObject* BezierCurvePy::isClosed(PyObject *args)
 
94
{
 
95
    if (!PyArg_ParseTuple(args, ""))
 
96
        return 0;
 
97
    Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
98
        (getGeometryPtr()->handle());
 
99
    Standard_Boolean val = curve->IsClosed();
 
100
    if (val) {
 
101
        Py_INCREF(Py_True);
 
102
        return Py_True;
 
103
    }
 
104
    else {
 
105
        Py_INCREF(Py_False);
 
106
        return Py_False;
 
107
    }
 
108
}
 
109
 
 
110
PyObject* BezierCurvePy::increase(PyObject * args)
 
111
{
 
112
    int degree;
 
113
    if (!PyArg_ParseTuple(args, "i", &degree))
 
114
        return 0;
 
115
    Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
116
        (getGeometryPtr()->handle());
 
117
    curve->Increase(degree);
 
118
    Py_Return;
 
119
}
 
120
 
 
121
PyObject* BezierCurvePy::insertPoleAfter(PyObject * args)
 
122
{
 
123
    int index;
 
124
    double weight=1.0;
 
125
    PyObject* p;
 
126
    if (!PyArg_ParseTuple(args, "iO!|d", &index, &(Base::VectorPy::Type), &p, &weight))
 
127
        return 0;
 
128
    Base::Vector3d vec = static_cast<Base::VectorPy*>(p)->value();
 
129
    gp_Pnt pnt(vec.x, vec.y, vec.z);
 
130
    try {
 
131
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
132
            (getGeometryPtr()->handle());
 
133
        curve->InsertPoleAfter(index,pnt,weight);
 
134
        Py_Return;
 
135
    }
 
136
    catch (Standard_Failure) {
 
137
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
138
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
139
        return 0;
 
140
    }
 
141
}
 
142
 
 
143
PyObject* BezierCurvePy::insertPoleBefore(PyObject * args)
 
144
{
 
145
    int index;
 
146
    double weight=1.0;
 
147
    PyObject* p;
 
148
    if (!PyArg_ParseTuple(args, "iO!|d", &index, &(Base::VectorPy::Type), &p, &weight))
 
149
        return 0;
 
150
    Base::Vector3d vec = static_cast<Base::VectorPy*>(p)->value();
 
151
    gp_Pnt pnt(vec.x, vec.y, vec.z);
 
152
    try {
 
153
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
154
            (getGeometryPtr()->handle());
 
155
        curve->InsertPoleBefore(index,pnt,weight);
 
156
        Py_Return;
 
157
    }
 
158
    catch (Standard_Failure) {
 
159
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
160
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
161
        return 0;
 
162
    }
 
163
}
 
164
 
 
165
PyObject* BezierCurvePy::removePole(PyObject * args)
 
166
{
 
167
    int index;
 
168
    if (!PyArg_ParseTuple(args, "i", &index))
 
169
        return 0;
 
170
    try {
 
171
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
172
            (getGeometryPtr()->handle());
 
173
        curve->RemovePole(index);
 
174
        Py_Return;
 
175
    }
 
176
    catch (Standard_Failure) {
 
177
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
178
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
179
        return 0;
 
180
    }
 
181
}
 
182
 
 
183
PyObject* BezierCurvePy::segment(PyObject * args)
 
184
{
 
185
    double u1,u2;
 
186
    if (!PyArg_ParseTuple(args, "dd", &u1,&u2))
 
187
        return 0;
 
188
    try {
 
189
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
190
            (getGeometryPtr()->handle());
 
191
        curve->Segment(u1,u2);
 
192
        Py_Return;
 
193
    }
 
194
    catch (Standard_Failure) {
 
195
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
196
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
197
        return 0;
 
198
    }
 
199
}
 
200
 
 
201
PyObject* BezierCurvePy::setPole(PyObject * args)
 
202
{
 
203
    int index;
 
204
    double weight=-1.0;
 
205
    PyObject* p;
 
206
    if (!PyArg_ParseTuple(args, "iO!|d", &index, &(Base::VectorPy::Type), &p, &weight))
 
207
        return 0;
 
208
    Base::Vector3d vec = static_cast<Base::VectorPy*>(p)->value();
 
209
    gp_Pnt pnt(vec.x, vec.y, vec.z);
 
210
    try {
 
211
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
212
            (getGeometryPtr()->handle());
 
213
        if (weight < 0.0)
 
214
            curve->SetPole(index,pnt);
 
215
        else
 
216
            curve->SetPole(index,pnt,weight);
 
217
        Py_Return;
 
218
    }
 
219
    catch (Standard_Failure) {
 
220
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
221
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
222
        return 0;
 
223
    }
 
224
}
 
225
 
 
226
PyObject* BezierCurvePy::getPole(PyObject * args)
 
227
{
 
228
    int index;
 
229
    if (!PyArg_ParseTuple(args, "i", &index))
 
230
        return 0;
 
231
    try {
 
232
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
233
            (getGeometryPtr()->handle());
 
234
        gp_Pnt pnt = curve->Pole(index);
 
235
        Base::VectorPy* vec = new Base::VectorPy(Base::Vector3d(
 
236
            pnt.X(), pnt.Y(), pnt.Z()));
 
237
        return vec;
 
238
    }
 
239
    catch (Standard_Failure) {
 
240
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
241
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
242
        return 0;
 
243
    }
 
244
}
 
245
 
 
246
PyObject* BezierCurvePy::getPoles(PyObject * args)
 
247
{
 
248
    if (!PyArg_ParseTuple(args, ""))
 
249
        return 0;
 
250
    try {
 
251
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
252
            (getGeometryPtr()->handle());
 
253
        TColgp_Array1OfPnt p(1,curve->NbPoles());
 
254
        curve->Poles(p);
 
255
        Py::List poles;
 
256
        for (Standard_Integer i=p.Lower(); i<=p.Upper(); i++) {
 
257
            gp_Pnt pnt = p(i);
 
258
            Base::VectorPy* vec = new Base::VectorPy(Base::Vector3d(
 
259
                pnt.X(), pnt.Y(), pnt.Z()));
 
260
            poles.append(Py::Object(vec));
 
261
        }
 
262
        return Py::new_reference_to(poles);
 
263
    }
 
264
    catch (Standard_Failure) {
 
265
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
266
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
267
        return 0;
 
268
    }
 
269
}
 
270
 
 
271
PyObject* BezierCurvePy::setWeight(PyObject * args)
 
272
{
 
273
    int index;
 
274
    double weight;
 
275
    if (!PyArg_ParseTuple(args, "id", &index,&weight))
 
276
        return 0;
 
277
    try {
 
278
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
279
            (getGeometryPtr()->handle());
 
280
        curve->SetWeight(index,weight);
 
281
        Py_Return;
 
282
    }
 
283
    catch (Standard_Failure) {
 
284
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
285
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
286
        return 0;
 
287
    }
 
288
}
 
289
 
 
290
PyObject* BezierCurvePy::getWeight(PyObject * args)
 
291
{
 
292
    int index;
 
293
    if (!PyArg_ParseTuple(args, "i", &index))
 
294
        return 0;
 
295
    try {
 
296
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
297
            (getGeometryPtr()->handle());
 
298
        double weight = curve->Weight(index);
 
299
        return Py_BuildValue("d", weight);
 
300
    }
 
301
    catch (Standard_Failure) {
 
302
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
303
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
304
        return 0;
 
305
    }
 
306
}
 
307
 
 
308
PyObject* BezierCurvePy::getWeights(PyObject * args)
 
309
{
 
310
    if (!PyArg_ParseTuple(args, ""))
 
311
        return 0;
 
312
    try {
 
313
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
314
            (getGeometryPtr()->handle());
 
315
        TColStd_Array1OfReal w(1,curve->NbPoles());
 
316
        curve->Weights(w);
 
317
        Py::List weights;
 
318
        for (Standard_Integer i=w.Lower(); i<=w.Upper(); i++) {
 
319
            weights.append(Py::Float(w(i)));
 
320
        }
 
321
        return Py::new_reference_to(weights);
 
322
    }
 
323
    catch (Standard_Failure) {
 
324
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
325
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
326
        return 0;
 
327
    }
 
328
}
 
329
 
 
330
PyObject* BezierCurvePy::getResolution(PyObject* args)
 
331
{
 
332
    double tol;
 
333
    if (!PyArg_ParseTuple(args, "d", &tol))
 
334
        return 0;
 
335
    try {
 
336
        Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
337
            (getGeometryPtr()->handle());
 
338
        double utol;
 
339
        curve->Resolution(tol,utol);
 
340
        return Py_BuildValue("d",utol);
 
341
    }
 
342
    catch (Standard_Failure) {
 
343
        Handle_Standard_Failure e = Standard_Failure::Caught();
 
344
        PyErr_SetString(PyExc_Exception, e->GetMessageString());
 
345
        return 0;
 
346
    }
 
347
}
 
348
 
 
349
Py::Int BezierCurvePy::getDegree(void) const
 
350
{
 
351
    Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
352
        (getGeometryPtr()->handle());
 
353
    return Py::Int(curve->Degree()); 
 
354
}
 
355
 
 
356
Py::Int BezierCurvePy::getMaxDegree(void) const
 
357
{
 
358
    Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
359
        (getGeometryPtr()->handle());
 
360
    return Py::Int(curve->MaxDegree()); 
 
361
}
 
362
 
 
363
Py::Int BezierCurvePy::getNbPoles(void) const
 
364
{
 
365
    Handle_Geom_BezierCurve curve = Handle_Geom_BezierCurve::DownCast
 
366
        (getGeometryPtr()->handle());
 
367
    return Py::Int(curve->NbPoles()); 
 
368
}
 
369
 
 
370
Py::Object BezierCurvePy::getStartPoint(void) const
 
371
{
 
372
    Handle_Geom_BezierCurve c = Handle_Geom_BezierCurve::DownCast
 
373
        (getGeometryPtr()->handle());
 
374
    gp_Pnt pnt = c->StartPoint();
 
375
    return Py::Vector(Base::Vector3d(pnt.X(), pnt.Y(), pnt.Z()));
 
376
}
 
377
 
 
378
Py::Object BezierCurvePy::getEndPoint(void) const
 
379
{
 
380
    Handle_Geom_BezierCurve c = Handle_Geom_BezierCurve::DownCast
 
381
        (getGeometryPtr()->handle());
 
382
    gp_Pnt pnt = c->EndPoint();
 
383
    return Py::Vector(Base::Vector3d(pnt.X(), pnt.Y(), pnt.Z()));
 
384
}
 
385
 
 
386
PyObject *BezierCurvePy::getCustomAttributes(const char* /*attr*/) const
 
387
{
 
388
    return 0;
 
389
}
 
390
 
 
391
int BezierCurvePy::setCustomAttributes(const char* /*attr*/, PyObject* /*obj*/)
 
392
{
 
393
    return 0; 
 
394
}