FreeCAD

1
/***************************************************************************
2
 *   Copyright (c) 2020 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 <TopoDS.hxx>
26
# include <TopoDS_Edge.hxx>
27
# include <TopoDS_Face.hxx>
28
#endif
29

30
#include <Base/PyWrapParseTupleAndKeywords.h>
31
#include <Base/VectorPy.h>
32

33
#include "BRepFeat/MakePrismPy.h"
34
#include "BRepFeat/MakePrismPy.cpp"
35
#include "Geometry.h"
36
#include "TopoShapeEdgePy.h"
37
#include "TopoShapeFacePy.h"
38

39

40
using namespace Part;
41

42
PyObject *MakePrismPy::PyMake(struct _typeobject *, PyObject *, PyObject *)  // Python wrapper
43
{
44
    // create a new instance of MakePrismPy
45
    return new MakePrismPy(nullptr);
46
}
47

48
// constructor method
49
int MakePrismPy::PyInit(PyObject* args, PyObject* kwds)
50
{
51
    PyObject* Sbase;
52
    PyObject* Pbase;
53
    PyObject* Skface;
54
    PyObject* Direction;
55
    int Fuse;
56
    PyObject* Modify;
57
    static const std::array<const char *, 7> keywords{"Sbase", "Pbase", "Skface", "Direction", "Fuse", "Modify",
58
                                                      nullptr};
59
    if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "O!O!O!O!iO!", keywords,
60
                                            &(TopoShapePy::Type), &Sbase,
61
                                            &(TopoShapePy::Type), &Pbase,
62
                                            &(TopoShapeFacePy::Type), &Skface,
63
                                            &(Base::VectorPy::Type), &Direction, &Fuse,
64
                                            &(PyBool_Type), &Modify)) {
65
        try {
66
            TopoDS_Shape sbase = static_cast<TopoShapePy*>(Sbase)->getTopoShapePtr()->getShape();
67
            TopoDS_Shape pbase = static_cast<TopoShapePy*>(Pbase)->getTopoShapePtr()->getShape();
68
            TopoDS_Face skface = TopoDS::Face(static_cast<TopoShapePy*>(Skface)->getTopoShapePtr()->getShape());
69
            Base::Vector3d dir = static_cast<Base::VectorPy*>(Direction)->value();
70
            std::unique_ptr<BRepFeat_MakePrism> ptr(new BRepFeat_MakePrism(sbase, pbase, skface, gp_Dir(dir.x, dir.y, dir.z), Fuse,
71
                                                                           Base::asBoolean(Modify)));
72

73
            setTwinPointer(ptr.release());
74
            return 0;
75
        }
76
        catch (const Standard_Failure& e) {
77
            PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
78
            return -1;
79
        }
80
    }
81

82
    PyErr_Clear();
83
    if (PyArg_ParseTuple(args, "")) {
84
        try {
85
            std::unique_ptr<BRepFeat_MakePrism> ptr(new BRepFeat_MakePrism());
86
            setTwinPointer(ptr.release());
87
            return 0;
88
        }
89
        catch (const Standard_Failure& e) {
90
            PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
91
            return -1;
92
        }
93
    }
94

95
    PyErr_SetString(PyExc_TypeError, "supported signatures:\n"
96
                    "MakePrism()\n"
97
                    "MakePrism(Sbase [shape], Pbase [shape], Skface [face], Direction [Vector], Fuse [int={0, 1}], Modify [bool])\n");
98
    return -1;
99
}
100

101
// returns a string which represents the object e.g. when printed in python
102
std::string MakePrismPy::representation() const
103
{
104
    return {"<BRepFeat_MakePrism object>"};
105
}
106

107
PyObject* MakePrismPy::init(PyObject *args,  PyObject* kwds)
108
{
109
    PyObject* Sbase;
110
    PyObject* Pbase;
111
    PyObject* Skface;
112
    PyObject* Direction;
113
    int Fuse;
114
    PyObject* Modify;
115
    static const std::array<const char *, 7> keywords{"Sbase", "Pbase", "Skface", "Direction", "Fuse", "Modify",
116
                                                      nullptr};
117
    if (!Base::Wrapped_ParseTupleAndKeywords(args, kwds, "O!O!O!O!iO!", keywords,
118
                                            &(TopoShapePy::Type), &Sbase,
119
                                            &(TopoShapePy::Type), &Pbase,
120
                                            &(TopoShapeFacePy::Type), &Skface,
121
                                            &(Base::VectorPy::Type), &Direction, &Fuse,
122
                                            &(PyBool_Type), &Modify)) {
123
        return nullptr;
124
    }
125

126

127
    try {
128
        TopoDS_Shape sbase = static_cast<TopoShapePy*>(Sbase)->getTopoShapePtr()->getShape();
129
        TopoDS_Shape pbase = static_cast<TopoShapePy*>(Pbase)->getTopoShapePtr()->getShape();
130
        TopoDS_Face skface = TopoDS::Face(static_cast<TopoShapePy*>(Skface)->getTopoShapePtr()->getShape());
131
        Base::Vector3d dir = static_cast<Base::VectorPy*>(Direction)->value();
132
        getBRepFeat_MakePrismPtr()->Init(sbase, pbase, skface, gp_Dir(dir.x, dir.y, dir.z), Fuse,
133
                                         Base::asBoolean(Modify));
134

135
        Py_Return;
136
    }
137
    catch (const Standard_Failure& e) {
138
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
139
        return nullptr;
140
    }
141
}
142

143
PyObject* MakePrismPy::add(PyObject *args,  PyObject* kwds)
144
{
145
    PyObject* Edge;
146
    PyObject* Face;
147
    static const std::array<const char *, 3> keywords{"Edge", "Face", nullptr};
148
    if (!Base::Wrapped_ParseTupleAndKeywords(args, kwds, "O!O!", keywords,
149
                                             &(TopoShapeEdgePy::Type), &Edge,
150
                                             &(TopoShapeFacePy::Type), &Face)) {
151
        return nullptr;
152
    }
153

154

155
    try {
156
        TopoDS_Edge edge = TopoDS::Edge(static_cast<TopoShapePy*>(Edge)->getTopoShapePtr()->getShape());
157
        TopoDS_Face face = TopoDS::Face(static_cast<TopoShapePy*>(Face)->getTopoShapePtr()->getShape());
158
        getBRepFeat_MakePrismPtr()->Add(edge, face);
159

160
        Py_Return;
161
    }
162
    catch (const Standard_Failure& e) {
163
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
164
        return nullptr;
165
    }
166
}
167

168
PyObject* MakePrismPy::perform(PyObject *args,  PyObject* kwds)
169
{
170
    PyObject* From;
171
    PyObject* Until;
172
    static const std::array<const char *, 3> keywords_fu{"From", "Until", nullptr};
173
    if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "O!O!", keywords_fu,
174
                                            &(TopoShapePy::Type), &From,
175
                                            &(TopoShapePy::Type), &Until)) {
176
        try {
177
            TopoDS_Shape from = static_cast<TopoShapePy*>(From)->getTopoShapePtr()->getShape();
178
            TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
179
            getBRepFeat_MakePrismPtr()->Perform(from, until);
180
            Py_Return;
181
        }
182
        catch (const Standard_Failure& e) {
183
            PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
184
            return nullptr;
185
        }
186
    }
187

188
    PyErr_Clear();
189
    static const std::array<const char *, 2> keywords_u {"Until", nullptr};
190
    if (Base:: Wrapped_ParseTupleAndKeywords(args, kwds, "O!", keywords_u, &(TopoShapePy::Type), &Until)) {
191
        try {
192
            TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
193
            getBRepFeat_MakePrismPtr()->Perform(until);
194
            Py_Return;
195
        }
196
        catch (const Standard_Failure& e) {
197
            PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
198
            return nullptr;
199
        }
200
    }
201

202
    PyErr_Clear();
203
    double length;
204
    static const std::array<const char *, 2> keywords_l {"Length", nullptr};
205
    if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "d", keywords_l, &length)) {
206
        try {
207
            getBRepFeat_MakePrismPtr()->Perform(length);
208
            Py_Return;
209
        }
210
        catch (const Standard_Failure& e) {
211
            PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
212
            return nullptr;
213
        }
214
    }
215

216
    PyErr_SetString(PyExc_TypeError, "supported signatures:\n"
217
                    "perform(From [shape], Until [shape])\n"
218
                    "perform(Until [shape])\n"
219
                    "perform(Length [float])\n");
220
    return nullptr;
221
}
222

223
PyObject* MakePrismPy::performUntilEnd(PyObject *args)
224
{
225
    if (!PyArg_ParseTuple(args, ""))
226
        return nullptr;
227

228
    try {
229
        getBRepFeat_MakePrismPtr()->PerformUntilEnd();
230
        Py_Return;
231
    }
232
    catch (const Standard_Failure& e) {
233
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
234
        return nullptr;
235
    }
236
}
237

238
PyObject* MakePrismPy::performFromEnd(PyObject *args)
239
{
240
    PyObject* Until;
241
    if (!PyArg_ParseTuple(args, "O!", &(TopoShapePy::Type), &Until))
242
        return nullptr;
243

244
    try {
245
        TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
246
        getBRepFeat_MakePrismPtr()->PerformFromEnd(until);
247
        Py_Return;
248
    }
249
    catch (const Standard_Failure& e) {
250
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
251
        return nullptr;
252
    }
253
}
254

255
PyObject* MakePrismPy::performThruAll(PyObject *args)
256
{
257
    if (!PyArg_ParseTuple(args, ""))
258
        return nullptr;
259

260
    try {
261
        getBRepFeat_MakePrismPtr()->PerformThruAll();
262
        Py_Return;
263
    }
264
    catch (const Standard_Failure& e) {
265
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
266
        return nullptr;
267
    }
268
}
269

270
PyObject* MakePrismPy::performUntilHeight(PyObject *args)
271
{
272
    PyObject* Until;
273
    double length;
274
    if (!PyArg_ParseTuple(args, "O!d", &(TopoShapePy::Type), &Until, &length))
275
        return nullptr;
276

277
    try {
278
        TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
279
        getBRepFeat_MakePrismPtr()->PerformUntilHeight(until, length);
280
        Py_Return;
281
    }
282
    catch (const Standard_Failure& e) {
283
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
284
        return nullptr;
285
    }
286
}
287

288
PyObject* MakePrismPy::curves(PyObject *args)
289
{
290
    if (!PyArg_ParseTuple(args, ""))
291
        return nullptr;
292

293
    TColGeom_SequenceOfCurve S;
294
    getBRepFeat_MakePrismPtr()->Curves(S);
295

296
    Py::Tuple tuple(S.Length());
297
    for (int i = S.Lower(); i <= S.Upper(); ++i) {
298
        Handle(Geom_Curve) hC = S.Value(i);
299
        if (hC.IsNull())
300
            continue;
301
        std::unique_ptr<GeomCurve> gc(Part::makeFromCurve(hC));
302
        tuple.setItem(i, Py::asObject(gc->getPyObject()));
303
    }
304

305
    return Py::new_reference_to(tuple);
306
}
307

308
PyObject* MakePrismPy::barycCurve(PyObject *args)
309
{
310
    if (!PyArg_ParseTuple(args, ""))
311
        return nullptr;
312

313
    Handle(Geom_Curve) hC = getBRepFeat_MakePrismPtr()->BarycCurve();
314
    if (hC.IsNull())
315
        Py_Return;
316
    std::unique_ptr<GeomCurve> gc(Part::makeFromCurve(hC));
317
    return gc->getPyObject();
318
}
319

320
PyObject* MakePrismPy::shape(PyObject *args)
321
{
322
    if (!PyArg_ParseTuple(args, ""))
323
        return nullptr;
324

325
    try {
326
        TopoShape shape(getBRepFeat_MakePrismPtr()->Shape());
327
        return shape.getPyObject();
328
    }
329
    catch (const Standard_Failure& e) {
330
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
331
        return nullptr;
332
    }
333
}
334

335
PyObject *MakePrismPy::getCustomAttributes(const char* /*attr*/) const
336
{
337
    return nullptr;
338
}
339

340
int MakePrismPy::setCustomAttributes(const char* /*attr*/, PyObject* /*obj*/)
341
{
342
    return 0;
343
}
344