FreeCAD / src /Mod /Part /App /BRepFeat /MakePrismPyImp.cpp

Upload folder using huggingface_hub

985c397 verified 9 months ago

12.5 kB

// SPDX-License-Identifier: LGPL-2.1-or-later

/***************************************************************************
 *   Copyright (c) 2020 Werner Mayer <wmayer[at]users.sourceforge.net>     *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  is distributed in the hope that it will be useful,      *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/

#include <Mod/Part/PartGlobal.h>

#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>


#include <Base/PyWrapParseTupleAndKeywords.h>
#include <Base/VectorPy.h>

#include "BRepFeat/MakePrismPy.h"
#include "BRepFeat/MakePrismPy.cpp"
#include "Geometry.h"
#include "TopoShapeEdgePy.h"
#include "TopoShapeFacePy.h"


using namespace Part;

PyObject* MakePrismPy::PyMake(struct _typeobject*, PyObject*, PyObject*)  // Python wrapper
{
    // create a new instance of MakePrismPy
    return new MakePrismPy(nullptr);
}

// constructor method
int MakePrismPy::PyInit(PyObject* args, PyObject* kwds)
{
    PyObject* Sbase;
    PyObject* Pbase;
    PyObject* Skface;
    PyObject* Direction;
    int Fuse;
    PyObject* Modify;
    static const std::array<const char*, 7>
        keywords {"Sbase", "Pbase", "Skface", "Direction", "Fuse", "Modify", nullptr};
    if (Base::Wrapped_ParseTupleAndKeywords(
            args,
            kwds,
            "O!O!O!O!iO!",
            keywords,
            &(TopoShapePy::Type),
            &Sbase,
            &(TopoShapePy::Type),
            &Pbase,
            &(TopoShapeFacePy::Type),
            &Skface,
            &(Base::VectorPy::Type),
            &Direction,
            &Fuse,
            &(PyBool_Type),
            &Modify
        )) {
        try {
            TopoDS_Shape sbase = static_cast<TopoShapePy*>(Sbase)->getTopoShapePtr()->getShape();
            TopoDS_Shape pbase = static_cast<TopoShapePy*>(Pbase)->getTopoShapePtr()->getShape();
            TopoDS_Face skface = TopoDS::Face(
                static_cast<TopoShapePy*>(Skface)->getTopoShapePtr()->getShape()
            );
            Base::Vector3d dir = static_cast<Base::VectorPy*>(Direction)->value();
            std::unique_ptr<BRepFeat_MakePrism> ptr(new BRepFeat_MakePrism(
                sbase,
                pbase,
                skface,
                gp_Dir(dir.x, dir.y, dir.z),
                Fuse,
                Base::asBoolean(Modify)
            ));

            setTwinPointer(ptr.release());
            return 0;
        }
        catch (const Standard_Failure& e) {
            PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
            return -1;
        }
    }

    PyErr_Clear();
    if (PyArg_ParseTuple(args, "")) {
        try {
            std::unique_ptr<BRepFeat_MakePrism> ptr(new BRepFeat_MakePrism());
            setTwinPointer(ptr.release());
            return 0;
        }
        catch (const Standard_Failure& e) {
            PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
            return -1;
        }
    }

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

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

PyObject* MakePrismPy::init(PyObject* args, PyObject* kwds)
{
    PyObject* Sbase;
    PyObject* Pbase;
    PyObject* Skface;
    PyObject* Direction;
    int Fuse;
    PyObject* Modify;
    static const std::array<const char*, 7>
        keywords {"Sbase", "Pbase", "Skface", "Direction", "Fuse", "Modify", nullptr};
    if (!Base::Wrapped_ParseTupleAndKeywords(
            args,
            kwds,
            "O!O!O!O!iO!",
            keywords,
            &(TopoShapePy::Type),
            &Sbase,
            &(TopoShapePy::Type),
            &Pbase,
            &(TopoShapeFacePy::Type),
            &Skface,
            &(Base::VectorPy::Type),
            &Direction,
            &Fuse,
            &(PyBool_Type),
            &Modify
        )) {
        return nullptr;
    }


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

        Py_Return;
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* MakePrismPy::add(PyObject* args, PyObject* kwds)
{
    PyObject* Edge;
    PyObject* Face;
    static const std::array<const char*, 3> keywords {"Edge", "Face", nullptr};
    if (!Base::Wrapped_ParseTupleAndKeywords(
            args,
            kwds,
            "O!O!",
            keywords,
            &(TopoShapeEdgePy::Type),
            &Edge,
            &(TopoShapeFacePy::Type),
            &Face
        )) {
        return nullptr;
    }


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

        Py_Return;
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* MakePrismPy::perform(PyObject* args, PyObject* kwds)
{
    PyObject* From;
    PyObject* Until;
    static const std::array<const char*, 3> keywords_fu {"From", "Until", nullptr};
    if (Base::Wrapped_ParseTupleAndKeywords(
            args,
            kwds,
            "O!O!",
            keywords_fu,
            &(TopoShapePy::Type),
            &From,
            &(TopoShapePy::Type),
            &Until
        )) {
        try {
            TopoDS_Shape from = static_cast<TopoShapePy*>(From)->getTopoShapePtr()->getShape();
            TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
            getBRepFeat_MakePrismPtr()->Perform(from, until);
            Py_Return;
        }
        catch (const Standard_Failure& e) {
            PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
            return nullptr;
        }
    }

    PyErr_Clear();
    static const std::array<const char*, 2> keywords_u {"Until", nullptr};
    if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "O!", keywords_u, &(TopoShapePy::Type), &Until)) {
        try {
            TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
            getBRepFeat_MakePrismPtr()->Perform(until);
            Py_Return;
        }
        catch (const Standard_Failure& e) {
            PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
            return nullptr;
        }
    }

    PyErr_Clear();
    double length;
    static const std::array<const char*, 2> keywords_l {"Length", nullptr};
    if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "d", keywords_l, &length)) {
        try {
            getBRepFeat_MakePrismPtr()->Perform(length);
            Py_Return;
        }
        catch (const Standard_Failure& e) {
            PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
            return nullptr;
        }
    }

    PyErr_SetString(
        PyExc_TypeError,
        "supported signatures:\n"
        "perform(From [shape], Until [shape])\n"
        "perform(Until [shape])\n"
        "perform(Length [float])\n"
    );
    return nullptr;
}

PyObject* MakePrismPy::performUntilEnd(PyObject* args)
{
    if (!PyArg_ParseTuple(args, "")) {
        return nullptr;
    }

    try {
        getBRepFeat_MakePrismPtr()->PerformUntilEnd();
        Py_Return;
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* MakePrismPy::performFromEnd(PyObject* args)
{
    PyObject* Until;
    if (!PyArg_ParseTuple(args, "O!", &(TopoShapePy::Type), &Until)) {
        return nullptr;
    }

    try {
        TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
        getBRepFeat_MakePrismPtr()->PerformFromEnd(until);
        Py_Return;
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* MakePrismPy::performThruAll(PyObject* args)
{
    if (!PyArg_ParseTuple(args, "")) {
        return nullptr;
    }

    try {
        getBRepFeat_MakePrismPtr()->PerformThruAll();
        Py_Return;
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* MakePrismPy::performUntilHeight(PyObject* args)
{
    PyObject* Until;
    double length;
    if (!PyArg_ParseTuple(args, "O!d", &(TopoShapePy::Type), &Until, &length)) {
        return nullptr;
    }

    try {
        TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
        getBRepFeat_MakePrismPtr()->PerformUntilHeight(until, length);
        Py_Return;
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* MakePrismPy::curves(PyObject* args) const
{
    if (!PyArg_ParseTuple(args, "")) {
        return nullptr;
    }

    TColGeom_SequenceOfCurve S;
    getBRepFeat_MakePrismPtr()->Curves(S);

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

    return Py::new_reference_to(tuple);
}

PyObject* MakePrismPy::barycCurve(PyObject* args) const
{
    if (!PyArg_ParseTuple(args, "")) {
        return nullptr;
    }

    Handle(Geom_Curve) hC = getBRepFeat_MakePrismPtr()->BarycCurve();
    if (hC.IsNull()) {
        Py_Return;
    }
    std::unique_ptr<GeomCurve> gc(Part::makeFromCurve(hC));
    return gc->getPyObject();
}

PyObject* MakePrismPy::shape(PyObject* args) const
{
    if (!PyArg_ParseTuple(args, "")) {
        return nullptr;
    }

    try {
        TopoShape shape(getBRepFeat_MakePrismPtr()->Shape());
        return shape.getPyObject();
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* MakePrismPy::getCustomAttributes(const char* /*attr*/) const
{
    return nullptr;
}

int MakePrismPy::setCustomAttributes(const char* /*attr*/, PyObject* /*obj*/)
{
    return 0;
}

	// SPDX-License-Identifier: LGPL-2.1-or-later

	/***************************************************************************
	* Copyright (c) 2020 Werner Mayer <wmayer[at]users.sourceforge.net> *
	* *
	* This file is part of the FreeCAD CAx development system. *
	* *
	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU Library General Public *
	* License as published by the Free Software Foundation; either *
	* version 2 of the License, or (at your option) any later version. *
	* *
	* This library is distributed in the hope that it will be useful, *
	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	* GNU Library General Public License for more details. *
	* *
	* You should have received a copy of the GNU Library General Public *
	* License along with this library; see the file COPYING.LIB. If not, *
	* write to the Free Software Foundation, Inc., 59 Temple Place, *
	* Suite 330, Boston, MA 02111-1307, USA *
	* *
	***************************************************************************/

	#include <Mod/Part/PartGlobal.h>

	#include <TopoDS.hxx>
	#include <TopoDS_Edge.hxx>
	#include <TopoDS_Face.hxx>


	#include <Base/PyWrapParseTupleAndKeywords.h>
	#include <Base/VectorPy.h>

	#include "BRepFeat/MakePrismPy.h"
	#include "BRepFeat/MakePrismPy.cpp"
	#include "Geometry.h"
	#include "TopoShapeEdgePy.h"
	#include "TopoShapeFacePy.h"


	using namespace Part;

	PyObject* MakePrismPy::PyMake(struct _typeobject, PyObject, PyObject*) // Python wrapper
	{
	// create a new instance of MakePrismPy
	return new MakePrismPy(nullptr);
	}

	// constructor method
	int MakePrismPy::PyInit(PyObject* args, PyObject* kwds)
	{
	PyObject* Sbase;
	PyObject* Pbase;
	PyObject* Skface;
	PyObject* Direction;
	int Fuse;
	PyObject* Modify;
	static const std::array<const char*, 7>
	keywords {"Sbase", "Pbase", "Skface", "Direction", "Fuse", "Modify", nullptr};
	if (Base::Wrapped_ParseTupleAndKeywords(
	args,
	kwds,
	"O!O!O!O!iO!",
	keywords,
	&(TopoShapePy::Type),
	&Sbase,
	&(TopoShapePy::Type),
	&Pbase,
	&(TopoShapeFacePy::Type),
	&Skface,
	&(Base::VectorPy::Type),
	&Direction,
	&Fuse,
	&(PyBool_Type),
	&Modify
	)) {
	try {
	TopoDS_Shape sbase = static_cast<TopoShapePy*>(Sbase)->getTopoShapePtr()->getShape();
	TopoDS_Shape pbase = static_cast<TopoShapePy*>(Pbase)->getTopoShapePtr()->getShape();
	TopoDS_Face skface = TopoDS::Face(
	static_cast<TopoShapePy*>(Skface)->getTopoShapePtr()->getShape()
	);
	Base::Vector3d dir = static_cast<Base::VectorPy*>(Direction)->value();
	std::unique_ptr<BRepFeat_MakePrism> ptr(new BRepFeat_MakePrism(
	sbase,
	pbase,
	skface,
	gp_Dir(dir.x, dir.y, dir.z),
	Fuse,
	Base::asBoolean(Modify)
	));

	setTwinPointer(ptr.release());
	return 0;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return -1;
	}
	}

	PyErr_Clear();
	if (PyArg_ParseTuple(args, "")) {
	try {
	std::unique_ptr<BRepFeat_MakePrism> ptr(new BRepFeat_MakePrism());
	setTwinPointer(ptr.release());
	return 0;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return -1;
	}
	}

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

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

	PyObject* MakePrismPy::init(PyObject* args, PyObject* kwds)
	{
	PyObject* Sbase;
	PyObject* Pbase;
	PyObject* Skface;
	PyObject* Direction;
	int Fuse;
	PyObject* Modify;
	static const std::array<const char*, 7>
	keywords {"Sbase", "Pbase", "Skface", "Direction", "Fuse", "Modify", nullptr};
	if (!Base::Wrapped_ParseTupleAndKeywords(
	args,
	kwds,
	"O!O!O!O!iO!",
	keywords,
	&(TopoShapePy::Type),
	&Sbase,
	&(TopoShapePy::Type),
	&Pbase,
	&(TopoShapeFacePy::Type),
	&Skface,
	&(Base::VectorPy::Type),
	&Direction,
	&Fuse,
	&(PyBool_Type),
	&Modify
	)) {
	return nullptr;
	}


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

	Py_Return;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* MakePrismPy::add(PyObject* args, PyObject* kwds)
	{
	PyObject* Edge;
	PyObject* Face;
	static const std::array<const char*, 3> keywords {"Edge", "Face", nullptr};
	if (!Base::Wrapped_ParseTupleAndKeywords(
	args,
	kwds,
	"O!O!",
	keywords,
	&(TopoShapeEdgePy::Type),
	&Edge,
	&(TopoShapeFacePy::Type),
	&Face
	)) {
	return nullptr;
	}


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

	Py_Return;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* MakePrismPy::perform(PyObject* args, PyObject* kwds)
	{
	PyObject* From;
	PyObject* Until;
	static const std::array<const char*, 3> keywords_fu {"From", "Until", nullptr};
	if (Base::Wrapped_ParseTupleAndKeywords(
	args,
	kwds,
	"O!O!",
	keywords_fu,
	&(TopoShapePy::Type),
	&From,
	&(TopoShapePy::Type),
	&Until
	)) {
	try {
	TopoDS_Shape from = static_cast<TopoShapePy*>(From)->getTopoShapePtr()->getShape();
	TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
	getBRepFeat_MakePrismPtr()->Perform(from, until);
	Py_Return;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyErr_Clear();
	static const std::array<const char*, 2> keywords_u {"Until", nullptr};
	if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "O!", keywords_u, &(TopoShapePy::Type), &Until)) {
	try {
	TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
	getBRepFeat_MakePrismPtr()->Perform(until);
	Py_Return;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyErr_Clear();
	double length;
	static const std::array<const char*, 2> keywords_l {"Length", nullptr};
	if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "d", keywords_l, &length)) {
	try {
	getBRepFeat_MakePrismPtr()->Perform(length);
	Py_Return;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyErr_SetString(
	PyExc_TypeError,
	"supported signatures:\n"
	"perform(From [shape], Until [shape])\n"
	"perform(Until [shape])\n"
	"perform(Length [float])\n"
	);
	return nullptr;
	}

	PyObject* MakePrismPy::performUntilEnd(PyObject* args)
	{
	if (!PyArg_ParseTuple(args, "")) {
	return nullptr;
	}

	try {
	getBRepFeat_MakePrismPtr()->PerformUntilEnd();
	Py_Return;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* MakePrismPy::performFromEnd(PyObject* args)
	{
	PyObject* Until;
	if (!PyArg_ParseTuple(args, "O!", &(TopoShapePy::Type), &Until)) {
	return nullptr;
	}

	try {
	TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
	getBRepFeat_MakePrismPtr()->PerformFromEnd(until);
	Py_Return;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* MakePrismPy::performThruAll(PyObject* args)
	{
	if (!PyArg_ParseTuple(args, "")) {
	return nullptr;
	}

	try {
	getBRepFeat_MakePrismPtr()->PerformThruAll();
	Py_Return;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* MakePrismPy::performUntilHeight(PyObject* args)
	{
	PyObject* Until;
	double length;
	if (!PyArg_ParseTuple(args, "O!d", &(TopoShapePy::Type), &Until, &length)) {
	return nullptr;
	}

	try {
	TopoDS_Shape until = static_cast<TopoShapePy*>(Until)->getTopoShapePtr()->getShape();
	getBRepFeat_MakePrismPtr()->PerformUntilHeight(until, length);
	Py_Return;
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* MakePrismPy::curves(PyObject* args) const
	{
	if (!PyArg_ParseTuple(args, "")) {
	return nullptr;
	}

	TColGeom_SequenceOfCurve S;
	getBRepFeat_MakePrismPtr()->Curves(S);

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

	return Py::new_reference_to(tuple);
	}

	PyObject* MakePrismPy::barycCurve(PyObject* args) const
	{
	if (!PyArg_ParseTuple(args, "")) {
	return nullptr;
	}

	Handle(Geom_Curve) hC = getBRepFeat_MakePrismPtr()->BarycCurve();
	if (hC.IsNull()) {
	Py_Return;
	}
	std::unique_ptr<GeomCurve> gc(Part::makeFromCurve(hC));
	return gc->getPyObject();
	}

	PyObject* MakePrismPy::shape(PyObject* args) const
	{
	if (!PyArg_ParseTuple(args, "")) {
	return nullptr;
	}

	try {
	TopoShape shape(getBRepFeat_MakePrismPtr()->Shape());
	return shape.getPyObject();
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* MakePrismPy::getCustomAttributes(const char* /attr/) const
	{
	return nullptr;
	}

	int MakePrismPy::setCustomAttributes(const char* /attr/, PyObject* /obj/)
	{
	return 0;
	}