FreeCAD / src /Mod /Part /App /GeomPlate /BuildPlateSurfacePyImp.cpp

Upload folder using huggingface_hub

985c397 verified 9 months ago

16.4 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 <Standard_Failure.hxx>


#include "GeomPlate/BuildPlateSurfacePy.h"
#include "GeomPlate/BuildPlateSurfacePy.cpp"
#include "GeomPlate/CurveConstraintPy.h"
#include "GeomPlate/PointConstraintPy.h"
#include "Geometry2d.h"
#include "GeometrySurfacePy.h"

#include <Base/PyWrapParseTupleAndKeywords.h>


using namespace Part;

/*!
 * \brief BuildPlateSurfacePy::PyMake
 * \code
v1=App.Vector(0,0,0)
v2=App.Vector(10,0,0)
v3=App.Vector(10,10,3)
v4=App.Vector(0,10,0)
v5=App.Vector(5,5,5)
l1=Part.LineSegment(v1, v2)
l2=Part.LineSegment(v2, v3)
l3=Part.LineSegment(v3, v4)
l4=Part.LineSegment(v4, v1)
c1=Part.GeomPlate.CurveConstraint(l1)
c2=Part.GeomPlate.CurveConstraint(l2)
c3=Part.GeomPlate.CurveConstraint(l3)
c4=Part.GeomPlate.CurveConstraint(l4)
c5=Part.GeomPlate.PointConstraint(v5)
bp=Part.GeomPlate.BuildPlateSurface()
bp.add(c1)
bp.add(c2)
bp.add(c3)
bp.add(c4)
bp.add(c5)
bp.perform()
s=bp.surface()
bs=s.makeApprox()
Part.show(bs.toShape())
Part.show(l1.toShape())
Part.show(l2.toShape())
Part.show(l3.toShape())
Part.show(l4.toShape())
bp.surfInit()
 * \endcode
 */
PyObject* BuildPlateSurfacePy::PyMake(struct _typeobject*, PyObject*, PyObject*)  // Python wrapper
{
    // create a new instance of BuildPlateSurfacePy
    return new BuildPlateSurfacePy(nullptr);
}

// constructor method
int BuildPlateSurfacePy::PyInit(PyObject* args, PyObject* kwds)
{
    PyObject* surf = nullptr;
    int degree = 3;
    int nbPtsOnCur = 10;
    int nbIter = 3;
    double tol2d = 0.00001;
    double tol3d = 0.0001;
    double tolAng = 0.01;
    double tolCurv = 0.1;
    PyObject* anisotropy = Py_False;

    static const std::array<const char*, 10> keywords {
        "Surface",
        "Degree",
        "NbPtsOnCur",
        "NbIter",
        "Tol2d",
        "Tol3d",
        "TolAng",
        "TolCurv",
        "Anisotropy",
        nullptr
    };
    if (!Base::Wrapped_ParseTupleAndKeywords(
            args,
            kwds,
            "|O!iiiddddO!",
            keywords,
            &(GeometrySurfacePy::Type),
            &surf,
            &degree,
            &nbPtsOnCur,
            &nbIter,
            &tol2d,
            &tol3d,
            &tolAng,
            &tolCurv,
            &PyBool_Type,
            &anisotropy
        )) {
        return -1;
    }

    try {
        std::unique_ptr<GeomPlate_BuildPlateSurface> ptr(new GeomPlate_BuildPlateSurface(
            degree,
            nbPtsOnCur,
            nbIter,
            tol2d,
            tol3d,
            tolAng,
            tolCurv,
            Base::asBoolean(anisotropy)
        ));

        if (surf) {
            GeomSurface* surface = static_cast<GeometrySurfacePy*>(surf)->getGeomSurfacePtr();
            Handle(Geom_Surface) handle = Handle(Geom_Surface)::DownCast(surface->handle());
            if (handle.IsNull()) {
                PyErr_SetString(PyExc_ReferenceError, "No valid surface handle");
                return -1;
            }
            ptr->LoadInitSurface(handle);
        }

        setTwinPointer(ptr.release());

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

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

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

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

PyObject* BuildPlateSurfacePy::loadInitSurface(PyObject* args)
{
    PyObject* surf;
    if (!PyArg_ParseTuple(args, "O!", &(GeometrySurfacePy::Type), &surf)) {
        return nullptr;
    }

    GeomSurface* surface = static_cast<GeometrySurfacePy*>(surf)->getGeomSurfacePtr();
    Handle(Geom_Surface) handle = Handle(Geom_Surface)::DownCast(surface->handle());
    if (handle.IsNull()) {
        PyErr_SetString(PyExc_ReferenceError, "No valid surface handle");
        return nullptr;
    }

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

PyObject* BuildPlateSurfacePy::add(PyObject* args)
{
    PyObject* cont;
    if (!PyArg_ParseTuple(args, "O", &cont)) {
        return nullptr;
    }

    try {
        if (PyObject_TypeCheck(cont, &PointConstraintPy::Type)) {
            GeomPlate_PointConstraint* pc
                = static_cast<PointConstraintPy*>(cont)->getGeomPlate_PointConstraintPtr();
            getGeomPlate_BuildPlateSurfacePtr()->Add(new GeomPlate_PointConstraint(*pc));
            Py_Return;
        }
        else if (PyObject_TypeCheck(cont, &CurveConstraintPy::Type)) {
            GeomPlate_CurveConstraint* cc
                = static_cast<CurveConstraintPy*>(cont)->getGeomPlate_CurveConstraintPtr();
            getGeomPlate_BuildPlateSurfacePtr()->Add(new GeomPlate_CurveConstraint(*cc));
            Py_Return;
        }
        else {
            PyErr_SetString(PyExc_TypeError, "PointConstraint or CurveConstraint expected");
            return nullptr;
        }
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* BuildPlateSurfacePy::setNbBounds(PyObject* args)
{
    int count;
    if (!PyArg_ParseTuple(args, "i", &count)) {
        return nullptr;
    }

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

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

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

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

    try {
        Standard_Boolean ok = getGeomPlate_BuildPlateSurfacePtr()->IsDone();
        return Py_BuildValue("O", (ok ? Py_True : Py_False));
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

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

    try {
        Handle(Geom_Surface) hSurf = getGeomPlate_BuildPlateSurfacePtr()->Surface();
        if (hSurf.IsNull()) {
            Py_Return;
        }

        std::unique_ptr<GeomSurface> geo(makeFromSurface(hSurf));
        return geo->getPyObject();
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

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

    try {
        Handle(Geom_Surface) hSurf = getGeomPlate_BuildPlateSurfacePtr()->SurfInit();
        if (hSurf.IsNull()) {
            Py_Return;
        }

        std::unique_ptr<GeomSurface> geo(makeFromSurface(hSurf));
        return geo->getPyObject();
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* BuildPlateSurfacePy::curveConstraint(PyObject* args) const
{
    int index;
    if (!PyArg_ParseTuple(args, "i", &index)) {
        return nullptr;
    }

    try {
        Handle(GeomPlate_CurveConstraint) hCC = getGeomPlate_BuildPlateSurfacePtr()->CurveConstraint(
            index
        );
        if (hCC.IsNull()) {
            Py_Return;
        }

        std::unique_ptr<GeomPlate_CurveConstraint> ptr(new GeomPlate_CurveConstraint(*hCC));
        return new CurveConstraintPy(ptr.release());
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* BuildPlateSurfacePy::pointConstraint(PyObject* args) const
{
    int index;
    if (!PyArg_ParseTuple(args, "i", &index)) {
        return nullptr;
    }

    try {
        Handle(GeomPlate_PointConstraint) hPC = getGeomPlate_BuildPlateSurfacePtr()->PointConstraint(
            index
        );
        if (hPC.IsNull()) {
            Py_Return;
        }

        std::unique_ptr<GeomPlate_PointConstraint> ptr(new GeomPlate_PointConstraint(*hPC));
        return new PointConstraintPy(ptr.release());
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* BuildPlateSurfacePy::disc2dContour(PyObject* args)
{
    int index;
    if (!PyArg_ParseTuple(args, "i", &index)) {
        return nullptr;
    }

    try {
        TColgp_SequenceOfXY seq2d;
        getGeomPlate_BuildPlateSurfacePtr()->Disc2dContour(index, seq2d);

        Py::List list;
        for (int i = seq2d.Lower(); i <= seq2d.Upper(); ++i) {
            const gp_XY& pnt = seq2d.Value(i);
            Py::Tuple coord(2);
            coord.setItem(0, Py::Float(pnt.X()));
            coord.setItem(1, Py::Float(pnt.Y()));
            list.append(coord);
        }

        return Py::new_reference_to(list);
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* BuildPlateSurfacePy::disc3dContour(PyObject* args)
{
    int index, order;
    if (!PyArg_ParseTuple(args, "ii", &index, &order)) {
        return nullptr;
    }

    try {
        TColgp_SequenceOfXYZ seq3d;
        getGeomPlate_BuildPlateSurfacePtr()->Disc3dContour(index, order, seq3d);

        Py::List list;
        for (int i = seq3d.Lower(); i <= seq3d.Upper(); ++i) {
            const gp_XYZ& pnt = seq3d.Value(i);
            Py::Tuple coord(3);
            coord.setItem(0, Py::Float(pnt.X()));
            coord.setItem(1, Py::Float(pnt.Y()));
            coord.setItem(2, Py::Float(pnt.Z()));
            list.append(coord);
        }

        return Py::new_reference_to(list);
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

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

    try {
        Handle(TColStd_HArray1OfInteger) hOrder = getGeomPlate_BuildPlateSurfacePtr()->Sense();
        Py::List list;
        if (!hOrder.IsNull()) {
            for (auto i = hOrder->Lower(); i <= hOrder->Upper(); ++i) {
                list.append(Py::Long(hOrder->Value(i)));
            }
        }
        return Py::new_reference_to(list);
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

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

    try {
        Handle(TColGeom2d_HArray1OfCurve) hCurves = getGeomPlate_BuildPlateSurfacePtr()->Curves2d();
        Py::List list;
        if (!hCurves.IsNull()) {
            for (auto i = hCurves->Lower(); i <= hCurves->Upper(); ++i) {
                Handle(Geom2d_Curve) hCurve = hCurves->Value(i);
                std::unique_ptr<Geom2dCurve> ptr(makeFromCurve2d(hCurve));
                if (ptr) {
                    list.append(Py::asObject(ptr->getPyObject()));
                }
            }
        }
        return Py::new_reference_to(list);
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

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

    try {
        Handle(TColStd_HArray1OfInteger) hOrder = getGeomPlate_BuildPlateSurfacePtr()->Order();
        Py::List list;
        if (!hOrder.IsNull()) {
            for (auto i = hOrder->Lower(); i <= hOrder->Upper(); ++i) {
                list.append(Py::Long(hOrder->Value(i)));
            }
        }
        return Py::new_reference_to(list);
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* BuildPlateSurfacePy::G0Error(PyObject* args) const
{
    int index = 0;
    if (!PyArg_ParseTuple(args, "|i", &index)) {
        return nullptr;
    }

    try {
        Standard_Real v = index < 1 ? getGeomPlate_BuildPlateSurfacePtr()->G0Error()
                                    : getGeomPlate_BuildPlateSurfacePtr()->G0Error(index);
        return PyFloat_FromDouble(v);
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* BuildPlateSurfacePy::G1Error(PyObject* args) const
{
    int index = 0;
    if (!PyArg_ParseTuple(args, "|i", &index)) {
        return nullptr;
    }

    try {
        Standard_Real v = index < 1 ? getGeomPlate_BuildPlateSurfacePtr()->G1Error()
                                    : getGeomPlate_BuildPlateSurfacePtr()->G1Error(index);
        return PyFloat_FromDouble(v);
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

PyObject* BuildPlateSurfacePy::G2Error(PyObject* args) const
{
    int index = 0;
    if (!PyArg_ParseTuple(args, "|i", &index)) {
        return nullptr;
    }

    try {
        Standard_Real v = index < 1 ? getGeomPlate_BuildPlateSurfacePtr()->G2Error()
                                    : getGeomPlate_BuildPlateSurfacePtr()->G2Error(index);
        return PyFloat_FromDouble(v);
    }
    catch (const Standard_Failure& e) {
        PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
        return nullptr;
    }
}

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

int BuildPlateSurfacePy::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 <Standard_Failure.hxx>


	#include "GeomPlate/BuildPlateSurfacePy.h"
	#include "GeomPlate/BuildPlateSurfacePy.cpp"
	#include "GeomPlate/CurveConstraintPy.h"
	#include "GeomPlate/PointConstraintPy.h"
	#include "Geometry2d.h"
	#include "GeometrySurfacePy.h"

	#include <Base/PyWrapParseTupleAndKeywords.h>


	using namespace Part;

	/*!
	* \brief BuildPlateSurfacePy::PyMake
	* \code
	v1=App.Vector(0,0,0)
	v2=App.Vector(10,0,0)
	v3=App.Vector(10,10,3)
	v4=App.Vector(0,10,0)
	v5=App.Vector(5,5,5)

	l1=Part.LineSegment(v1, v2)
	l2=Part.LineSegment(v2, v3)
	l3=Part.LineSegment(v3, v4)
	l4=Part.LineSegment(v4, v1)

	c1=Part.GeomPlate.CurveConstraint(l1)
	c2=Part.GeomPlate.CurveConstraint(l2)
	c3=Part.GeomPlate.CurveConstraint(l3)
	c4=Part.GeomPlate.CurveConstraint(l4)
	c5=Part.GeomPlate.PointConstraint(v5)

	bp=Part.GeomPlate.BuildPlateSurface()
	bp.add(c1)
	bp.add(c2)
	bp.add(c3)
	bp.add(c4)
	bp.add(c5)
	bp.perform()
	s=bp.surface()
	bs=s.makeApprox()
	Part.show(bs.toShape())
	Part.show(l1.toShape())
	Part.show(l2.toShape())
	Part.show(l3.toShape())
	Part.show(l4.toShape())

	bp.surfInit()
	* \endcode
	*/
	PyObject* BuildPlateSurfacePy::PyMake(struct _typeobject, PyObject, PyObject*) // Python wrapper
	{
	// create a new instance of BuildPlateSurfacePy
	return new BuildPlateSurfacePy(nullptr);
	}

	// constructor method
	int BuildPlateSurfacePy::PyInit(PyObject* args, PyObject* kwds)
	{
	PyObject* surf = nullptr;
	int degree = 3;
	int nbPtsOnCur = 10;
	int nbIter = 3;
	double tol2d = 0.00001;
	double tol3d = 0.0001;
	double tolAng = 0.01;
	double tolCurv = 0.1;
	PyObject* anisotropy = Py_False;

	static const std::array<const char*, 10> keywords {
	"Surface",
	"Degree",
	"NbPtsOnCur",
	"NbIter",
	"Tol2d",
	"Tol3d",
	"TolAng",
	"TolCurv",
	"Anisotropy",
	nullptr
	};
	if (!Base::Wrapped_ParseTupleAndKeywords(
	args,
	kwds,
	"\|O!iiiddddO!",
	keywords,
	&(GeometrySurfacePy::Type),
	&surf,
	&degree,
	&nbPtsOnCur,
	&nbIter,
	&tol2d,
	&tol3d,
	&tolAng,
	&tolCurv,
	&PyBool_Type,
	&anisotropy
	)) {
	return -1;
	}

	try {
	std::unique_ptr<GeomPlate_BuildPlateSurface> ptr(new GeomPlate_BuildPlateSurface(
	degree,
	nbPtsOnCur,
	nbIter,
	tol2d,
	tol3d,
	tolAng,
	tolCurv,
	Base::asBoolean(anisotropy)
	));

	if (surf) {
	GeomSurface* surface = static_cast<GeometrySurfacePy*>(surf)->getGeomSurfacePtr();
	Handle(Geom_Surface) handle = Handle(Geom_Surface)::DownCast(surface->handle());
	if (handle.IsNull()) {
	PyErr_SetString(PyExc_ReferenceError, "No valid surface handle");
	return -1;
	}
	ptr->LoadInitSurface(handle);
	}

	setTwinPointer(ptr.release());

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

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

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

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

	PyObject* BuildPlateSurfacePy::loadInitSurface(PyObject* args)
	{
	PyObject* surf;
	if (!PyArg_ParseTuple(args, "O!", &(GeometrySurfacePy::Type), &surf)) {
	return nullptr;
	}

	GeomSurface* surface = static_cast<GeometrySurfacePy*>(surf)->getGeomSurfacePtr();
	Handle(Geom_Surface) handle = Handle(Geom_Surface)::DownCast(surface->handle());
	if (handle.IsNull()) {
	PyErr_SetString(PyExc_ReferenceError, "No valid surface handle");
	return nullptr;
	}

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

	PyObject* BuildPlateSurfacePy::add(PyObject* args)
	{
	PyObject* cont;
	if (!PyArg_ParseTuple(args, "O", &cont)) {
	return nullptr;
	}

	try {
	if (PyObject_TypeCheck(cont, &PointConstraintPy::Type)) {
	GeomPlate_PointConstraint* pc
	= static_cast<PointConstraintPy*>(cont)->getGeomPlate_PointConstraintPtr();
	getGeomPlate_BuildPlateSurfacePtr()->Add(new GeomPlate_PointConstraint(*pc));
	Py_Return;
	}
	else if (PyObject_TypeCheck(cont, &CurveConstraintPy::Type)) {
	GeomPlate_CurveConstraint* cc
	= static_cast<CurveConstraintPy*>(cont)->getGeomPlate_CurveConstraintPtr();
	getGeomPlate_BuildPlateSurfacePtr()->Add(new GeomPlate_CurveConstraint(*cc));
	Py_Return;
	}
	else {
	PyErr_SetString(PyExc_TypeError, "PointConstraint or CurveConstraint expected");
	return nullptr;
	}
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* BuildPlateSurfacePy::setNbBounds(PyObject* args)
	{
	int count;
	if (!PyArg_ParseTuple(args, "i", &count)) {
	return nullptr;
	}

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

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

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

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

	try {
	Standard_Boolean ok = getGeomPlate_BuildPlateSurfacePtr()->IsDone();
	return Py_BuildValue("O", (ok ? Py_True : Py_False));
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

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

	try {
	Handle(Geom_Surface) hSurf = getGeomPlate_BuildPlateSurfacePtr()->Surface();
	if (hSurf.IsNull()) {
	Py_Return;
	}

	std::unique_ptr<GeomSurface> geo(makeFromSurface(hSurf));
	return geo->getPyObject();
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

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

	try {
	Handle(Geom_Surface) hSurf = getGeomPlate_BuildPlateSurfacePtr()->SurfInit();
	if (hSurf.IsNull()) {
	Py_Return;
	}

	std::unique_ptr<GeomSurface> geo(makeFromSurface(hSurf));
	return geo->getPyObject();
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* BuildPlateSurfacePy::curveConstraint(PyObject* args) const
	{
	int index;
	if (!PyArg_ParseTuple(args, "i", &index)) {
	return nullptr;
	}

	try {
	Handle(GeomPlate_CurveConstraint) hCC = getGeomPlate_BuildPlateSurfacePtr()->CurveConstraint(
	index
	);
	if (hCC.IsNull()) {
	Py_Return;
	}

	std::unique_ptr<GeomPlate_CurveConstraint> ptr(new GeomPlate_CurveConstraint(*hCC));
	return new CurveConstraintPy(ptr.release());
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* BuildPlateSurfacePy::pointConstraint(PyObject* args) const
	{
	int index;
	if (!PyArg_ParseTuple(args, "i", &index)) {
	return nullptr;
	}

	try {
	Handle(GeomPlate_PointConstraint) hPC = getGeomPlate_BuildPlateSurfacePtr()->PointConstraint(
	index
	);
	if (hPC.IsNull()) {
	Py_Return;
	}

	std::unique_ptr<GeomPlate_PointConstraint> ptr(new GeomPlate_PointConstraint(*hPC));
	return new PointConstraintPy(ptr.release());
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* BuildPlateSurfacePy::disc2dContour(PyObject* args)
	{
	int index;
	if (!PyArg_ParseTuple(args, "i", &index)) {
	return nullptr;
	}

	try {
	TColgp_SequenceOfXY seq2d;
	getGeomPlate_BuildPlateSurfacePtr()->Disc2dContour(index, seq2d);

	Py::List list;
	for (int i = seq2d.Lower(); i <= seq2d.Upper(); ++i) {
	const gp_XY& pnt = seq2d.Value(i);
	Py::Tuple coord(2);
	coord.setItem(0, Py::Float(pnt.X()));
	coord.setItem(1, Py::Float(pnt.Y()));
	list.append(coord);
	}

	return Py::new_reference_to(list);
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* BuildPlateSurfacePy::disc3dContour(PyObject* args)
	{
	int index, order;
	if (!PyArg_ParseTuple(args, "ii", &index, &order)) {
	return nullptr;
	}

	try {
	TColgp_SequenceOfXYZ seq3d;
	getGeomPlate_BuildPlateSurfacePtr()->Disc3dContour(index, order, seq3d);

	Py::List list;
	for (int i = seq3d.Lower(); i <= seq3d.Upper(); ++i) {
	const gp_XYZ& pnt = seq3d.Value(i);
	Py::Tuple coord(3);
	coord.setItem(0, Py::Float(pnt.X()));
	coord.setItem(1, Py::Float(pnt.Y()));
	coord.setItem(2, Py::Float(pnt.Z()));
	list.append(coord);
	}

	return Py::new_reference_to(list);
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

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

	try {
	Handle(TColStd_HArray1OfInteger) hOrder = getGeomPlate_BuildPlateSurfacePtr()->Sense();
	Py::List list;
	if (!hOrder.IsNull()) {
	for (auto i = hOrder->Lower(); i <= hOrder->Upper(); ++i) {
	list.append(Py::Long(hOrder->Value(i)));
	}
	}
	return Py::new_reference_to(list);
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

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

	try {
	Handle(TColGeom2d_HArray1OfCurve) hCurves = getGeomPlate_BuildPlateSurfacePtr()->Curves2d();
	Py::List list;
	if (!hCurves.IsNull()) {
	for (auto i = hCurves->Lower(); i <= hCurves->Upper(); ++i) {
	Handle(Geom2d_Curve) hCurve = hCurves->Value(i);
	std::unique_ptr<Geom2dCurve> ptr(makeFromCurve2d(hCurve));
	if (ptr) {
	list.append(Py::asObject(ptr->getPyObject()));
	}
	}
	}
	return Py::new_reference_to(list);
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

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

	try {
	Handle(TColStd_HArray1OfInteger) hOrder = getGeomPlate_BuildPlateSurfacePtr()->Order();
	Py::List list;
	if (!hOrder.IsNull()) {
	for (auto i = hOrder->Lower(); i <= hOrder->Upper(); ++i) {
	list.append(Py::Long(hOrder->Value(i)));
	}
	}
	return Py::new_reference_to(list);
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* BuildPlateSurfacePy::G0Error(PyObject* args) const
	{
	int index = 0;
	if (!PyArg_ParseTuple(args, "\|i", &index)) {
	return nullptr;
	}

	try {
	Standard_Real v = index < 1 ? getGeomPlate_BuildPlateSurfacePtr()->G0Error()
	: getGeomPlate_BuildPlateSurfacePtr()->G0Error(index);
	return PyFloat_FromDouble(v);
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* BuildPlateSurfacePy::G1Error(PyObject* args) const
	{
	int index = 0;
	if (!PyArg_ParseTuple(args, "\|i", &index)) {
	return nullptr;
	}

	try {
	Standard_Real v = index < 1 ? getGeomPlate_BuildPlateSurfacePtr()->G1Error()
	: getGeomPlate_BuildPlateSurfacePtr()->G1Error(index);
	return PyFloat_FromDouble(v);
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

	PyObject* BuildPlateSurfacePy::G2Error(PyObject* args) const
	{
	int index = 0;
	if (!PyArg_ParseTuple(args, "\|i", &index)) {
	return nullptr;
	}

	try {
	Standard_Real v = index < 1 ? getGeomPlate_BuildPlateSurfacePtr()->G2Error()
	: getGeomPlate_BuildPlateSurfacePtr()->G2Error(index);
	return PyFloat_FromDouble(v);
	}
	catch (const Standard_Failure& e) {
	PyErr_SetString(PyExc_RuntimeError, e.GetMessageString());
	return nullptr;
	}
	}

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

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