BoundBoxPy.cpp

Go to the documentation of this file.

// This file is generated by src/Tools/generateTemaplates/templateClassPyExport.py out of the .XML file
// Every change you make here get lost at the next full rebuild!
// This File is normaly build as an include in BoundBoxPyImp.cpp! Its not intended to be in a project!

#include <boost/filesystem/path.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/exception.hpp>
#include <Base/PyObjectBase.h>
#include <Base/Console.h>
#include <Base/Exception.h>
#include <CXX/Objects.hxx>

#define new DEBUG_CLIENTBLOCK

using Base::streq;
using namespace Base;

PyTypeObject BoundBoxPy::Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,                                                /*ob_size*/
    "Base.BoundBox",     /*tp_name*/
    sizeof(BoundBoxPy),                       /*tp_basicsize*/
    0,                                                /*tp_itemsize*/
    /* methods */
    PyDestructor,                                     /*tp_dealloc*/
    0,                                                /*tp_print*/
    __getattr,                                        /*tp_getattr*/
    __setattr,                                        /*tp_setattr*/
    0,                                                /*tp_compare*/
    __repr,                                           /*tp_repr*/
    0,                                                /*tp_as_number*/
    0,                                                /*tp_as_sequence*/
    0,                                                /*tp_as_mapping*/
    0,                                                /*tp_hash*/
    0,                                                /*tp_call */
    0,                                                /*tp_str  */
    0,                                                /*tp_getattro*/
    0,                                                /*tp_setattro*/
    /* --- Functions to access object as input/output buffer ---------*/
    0,                                                /* tp_as_buffer */
    /* --- Flags to define presence of optional/expanded features */
    Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_CLASS,        /*tp_flags */
    "Bound box class\n"
    "A bounding box is an orthographic cube which is a way to describe outer boundaries.\n"
    "You get a bounding box from a lot of 3D types. It is often used to check if a 3D\n"
    "entity lies in the range of another object. Checking for boundig interference first\n"
    "can save a lot of computing time!\n"
    "\n"
    "Constructor:\n"
    "App.BoundBox([Xmin,Ymin,Zmin,Xmax,Ymax,Zmax])\n"
    "App.BoundBox(Tuple, Tuple)\n"
    "App.BoundBox(Vector, Vector)\n"
    "App.BoundBox(BoundBox)\n"
    "     ",           /*tp_doc */
    0,                                                /*tp_traverse */
    0,                                                /*tp_clear */
    0,                                                /*tp_richcompare */
    0,                                                /*tp_weaklistoffset */
    0,                                                /*tp_iter */
    0,                                                /*tp_iternext */
    Base::BoundBoxPy::Methods,                     /*tp_methods */
    0,                                                /*tp_members */
    Base::BoundBoxPy::GetterSetter,                     /*tp_getset */
    &Base::PyObjectBase::Type,                        /*tp_base */
    0,                                                /*tp_dict */
    0,                                                /*tp_descr_get */
    0,                                                /*tp_descr_set */
    0,                                                /*tp_dictoffset */
    __PyInit,                                         /*tp_init */
    0,                                                /*tp_alloc */
    Base::BoundBoxPy::PyMake,/*tp_new */
    0,                                                /*tp_free   Low-level free-memory routine */
    0,                                                /*tp_is_gc  For PyObject_IS_GC */
    0,                                                /*tp_bases */
    0,                                                /*tp_mro    method resolution order */
    0,                                                /*tp_cache */
    0,                                                /*tp_subclasses */
    0,                                                /*tp_weaklist */
    0                                                 /*tp_del */
};

PyMethodDef BoundBoxPy::Methods[] = {
    {"add",
        (PyCFunction) staticCallback_add,
        METH_VARARGS,
        "method add(BoundBox)\nAdd (enlarge) the given BoundBox"
    },
    {"isIntersection",
        (PyCFunction) staticCallback_isIntersection,
        METH_VARARGS,
        "method isIntersection(Vector|BoundBox|Vector Base, Vector Dir)\nChecks if the given object intersects with the BoundBox. That can be:\n- A Vector (Point)\n- Another BoundBox\n- A line, specified by Base and Dir\n           "
    },
    {"enlarge",
        (PyCFunction) staticCallback_enlarge,
        METH_VARARGS,
        "method enlarge(Float)\nEnlarge the BoundBox by the given value in each direction.\nA negative value shrinks the box."
    },
    {"getIntersectionPoint",
        (PyCFunction) staticCallback_getIntersectionPoint,
        METH_VARARGS,
        "method Vector getIntersectionPoint(Vector Base, Vector Dir, [float epsilon=0.0001])\nCalculate the intersection point of a line with the BoundBox\nThe Base point must lie inside the bounding box, if not an\nexception is thrown.\n                    "
    },
    {"move",
        (PyCFunction) staticCallback_move,
        METH_VARARGS,
        " method getIntersectionPoint(Vector)\nMove the BoundBox by the given vector\n                    "
    },
    {"isCutPlane",
        (PyCFunction) staticCallback_isCutPlane,
        METH_VARARGS,
        "method bool isCutPlane(Vector Base, Vector Normal)\nCheck if the plane specified by Base and Normal intersects (cuts) the BoundBox"
    },
    {"isInside",
        (PyCFunction) staticCallback_isInside,
        METH_VARARGS,
        "\n                                     method bool isInside(Vector Base|BoundBox box)\nCheck if the point or bounding box is inside this bounding box\n                                "
    },
    {NULL, NULL, 0, NULL}               /* Sentinel */
};



PyGetSetDef BoundBoxPy::GetterSetter[] = {
    {"Center",
        (getter) staticCallback_getCenter,
        (setter) staticCallback_setCenter, 
        "Center point of the bounding box",
        NULL
    },
    {"XMax",
        (getter) staticCallback_getXMax,
        (setter) staticCallback_setXMax, 
        "The maximum x boundary position",
        NULL
    },
    {"YMax",
        (getter) staticCallback_getYMax,
        (setter) staticCallback_setYMax, 
        "The maximum y boundary position",
        NULL
    },
    {"ZMax",
        (getter) staticCallback_getZMax,
        (setter) staticCallback_setZMax, 
        "The maximum z boundary position",
        NULL
    },
    {"XMin",
        (getter) staticCallback_getXMin,
        (setter) staticCallback_setXMin, 
        "The minimum x boundary position",
        NULL
    },
    {"YMin",
        (getter) staticCallback_getYMin,
        (setter) staticCallback_setYMin, 
        "The minimum y boundary position",
        NULL
    },
    {"ZMin",
        (getter) staticCallback_getZMin,
        (setter) staticCallback_setZMin, 
        "The minimum z boundary position",
        NULL
    },
    {"XLength",
        (getter) staticCallback_getXLength,
        (setter) staticCallback_setXLength, 
        "Length of the BoundBox in x direction",
        NULL
    },
    {"YLength",
        (getter) staticCallback_getYLength,
        (setter) staticCallback_setYLength, 
        "Length of the BoundBox in y direction",
        NULL
    },
    {"ZLength",
        (getter) staticCallback_getZLength,
        (setter) staticCallback_setZLength, 
        "Length of the BoundBox in z direction",
        NULL
    },
    {"DiagonalLength",
        (getter) staticCallback_getDiagonalLength,
        (setter) staticCallback_setDiagonalLength, 
        "Diagonal length of the BoundBox",
        NULL
    },
    {NULL, NULL, NULL, NULL, NULL}              /* Sentinel */
};

// add() callback and implementer
// PyObject*  BoundBoxPy::add(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_add (PyObject *self, PyObject *args)
{
    // test if twin object not allready deleted
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    // test if object is set Const
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a non const method");
        return NULL;
    }

    try { // catches all exceptions coming up from c++ and generate a python exception
        PyObject* ret = ((BoundBoxPy*)self)->add(args);
        if (ret != 0)
            ((BoundBoxPy*)self)->startNotify();
        return ret;
    }
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const boost::filesystem::filesystem_error& e) // catch boost filesystem exception
    {
        std::string str;
        str += "File system exception thrown (";
        //str += e.who();
        //str += ", ";
        str += e.what();
        str += ")\n";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
    catch(const char* e) // catch simple string exceptions
    {
        Base::Console().Error(e);
        PyErr_SetString(PyExc_Exception,e);
        return NULL;
    }
    // in debug not all exceptions will be catched to get the attention of the developer!
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return NULL;
    }
#endif
}

// isIntersection() callback and implementer
// PyObject*  BoundBoxPy::isIntersection(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_isIntersection (PyObject *self, PyObject *args)
{
    // test if twin object not allready deleted
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    // test if object is set Const
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a non const method");
        return NULL;
    }

    try { // catches all exceptions coming up from c++ and generate a python exception
        PyObject* ret = ((BoundBoxPy*)self)->isIntersection(args);
        if (ret != 0)
            ((BoundBoxPy*)self)->startNotify();
        return ret;
    }
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const boost::filesystem::filesystem_error& e) // catch boost filesystem exception
    {
        std::string str;
        str += "File system exception thrown (";
        //str += e.who();
        //str += ", ";
        str += e.what();
        str += ")\n";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
    catch(const char* e) // catch simple string exceptions
    {
        Base::Console().Error(e);
        PyErr_SetString(PyExc_Exception,e);
        return NULL;
    }
    // in debug not all exceptions will be catched to get the attention of the developer!
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return NULL;
    }
#endif
}

// enlarge() callback and implementer
// PyObject*  BoundBoxPy::enlarge(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_enlarge (PyObject *self, PyObject *args)
{
    // test if twin object not allready deleted
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    // test if object is set Const
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a non const method");
        return NULL;
    }

    try { // catches all exceptions coming up from c++ and generate a python exception
        PyObject* ret = ((BoundBoxPy*)self)->enlarge(args);
        if (ret != 0)
            ((BoundBoxPy*)self)->startNotify();
        return ret;
    }
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const boost::filesystem::filesystem_error& e) // catch boost filesystem exception
    {
        std::string str;
        str += "File system exception thrown (";
        //str += e.who();
        //str += ", ";
        str += e.what();
        str += ")\n";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
    catch(const char* e) // catch simple string exceptions
    {
        Base::Console().Error(e);
        PyErr_SetString(PyExc_Exception,e);
        return NULL;
    }
    // in debug not all exceptions will be catched to get the attention of the developer!
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return NULL;
    }
#endif
}

// getIntersectionPoint() callback and implementer
// PyObject*  BoundBoxPy::getIntersectionPoint(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getIntersectionPoint (PyObject *self, PyObject *args)
{
    // test if twin object not allready deleted
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    // test if object is set Const
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a non const method");
        return NULL;
    }

    try { // catches all exceptions coming up from c++ and generate a python exception
        PyObject* ret = ((BoundBoxPy*)self)->getIntersectionPoint(args);
        if (ret != 0)
            ((BoundBoxPy*)self)->startNotify();
        return ret;
    }
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const boost::filesystem::filesystem_error& e) // catch boost filesystem exception
    {
        std::string str;
        str += "File system exception thrown (";
        //str += e.who();
        //str += ", ";
        str += e.what();
        str += ")\n";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
    catch(const char* e) // catch simple string exceptions
    {
        Base::Console().Error(e);
        PyErr_SetString(PyExc_Exception,e);
        return NULL;
    }
    // in debug not all exceptions will be catched to get the attention of the developer!
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return NULL;
    }
#endif
}

// move() callback and implementer
// PyObject*  BoundBoxPy::move(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_move (PyObject *self, PyObject *args)
{
    // test if twin object not allready deleted
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    // test if object is set Const
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a non const method");
        return NULL;
    }

    try { // catches all exceptions coming up from c++ and generate a python exception
        PyObject* ret = ((BoundBoxPy*)self)->move(args);
        if (ret != 0)
            ((BoundBoxPy*)self)->startNotify();
        return ret;
    }
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const boost::filesystem::filesystem_error& e) // catch boost filesystem exception
    {
        std::string str;
        str += "File system exception thrown (";
        //str += e.who();
        //str += ", ";
        str += e.what();
        str += ")\n";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
    catch(const char* e) // catch simple string exceptions
    {
        Base::Console().Error(e);
        PyErr_SetString(PyExc_Exception,e);
        return NULL;
    }
    // in debug not all exceptions will be catched to get the attention of the developer!
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return NULL;
    }
#endif
}

// isCutPlane() callback and implementer
// PyObject*  BoundBoxPy::isCutPlane(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_isCutPlane (PyObject *self, PyObject *args)
{
    // test if twin object not allready deleted
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    // test if object is set Const
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a non const method");
        return NULL;
    }

    try { // catches all exceptions coming up from c++ and generate a python exception
        PyObject* ret = ((BoundBoxPy*)self)->isCutPlane(args);
        if (ret != 0)
            ((BoundBoxPy*)self)->startNotify();
        return ret;
    }
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const boost::filesystem::filesystem_error& e) // catch boost filesystem exception
    {
        std::string str;
        str += "File system exception thrown (";
        //str += e.who();
        //str += ", ";
        str += e.what();
        str += ")\n";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
    catch(const char* e) // catch simple string exceptions
    {
        Base::Console().Error(e);
        PyErr_SetString(PyExc_Exception,e);
        return NULL;
    }
    // in debug not all exceptions will be catched to get the attention of the developer!
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return NULL;
    }
#endif
}

// isInside() callback and implementer
// PyObject*  BoundBoxPy::isInside(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_isInside (PyObject *self, PyObject *args)
{
    // test if twin object not allready deleted
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    // test if object is set Const
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a non const method");
        return NULL;
    }

    try { // catches all exceptions coming up from c++ and generate a python exception
        PyObject* ret = ((BoundBoxPy*)self)->isInside(args);
        if (ret != 0)
            ((BoundBoxPy*)self)->startNotify();
        return ret;
    }
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const boost::filesystem::filesystem_error& e) // catch boost filesystem exception
    {
        std::string str;
        str += "File system exception thrown (";
        //str += e.who();
        //str += ", ";
        str += e.what();
        str += ")\n";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
    catch(const char* e) // catch simple string exceptions
    {
        Base::Console().Error(e);
        PyErr_SetString(PyExc_Exception,e);
        return NULL;
    }
    // in debug not all exceptions will be catched to get the attention of the developer!
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return NULL;
    }
#endif
}

// Center() callback and implementer
// PyObject*  BoundBoxPy::Center(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getCenter (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getCenter());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'Center' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setCenter (PyObject *self, PyObject * /*value*/, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }

    PyErr_SetString(PyExc_AttributeError, "Attribute 'Center' of object 'BoundBox' is read-only");
    return -1;
}

// XMax() callback and implementer
// PyObject*  BoundBoxPy::XMax(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getXMax (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getXMax());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'XMax' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setXMax (PyObject *self, PyObject *value, void * /*closure*/)
{    
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
        return -1;
    }

    try {
        ((BoundBoxPy*)self)->setXMax(Py::Float(value,false));
        return 0;
    } catch (const Py::Exception&) {
        // The exception text is already set
        return -1;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'XMax' of object 'BoundBox'");
        return -1;
    }
}

// YMax() callback and implementer
// PyObject*  BoundBoxPy::YMax(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getYMax (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getYMax());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'YMax' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setYMax (PyObject *self, PyObject *value, void * /*closure*/)
{    
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
        return -1;
    }

    try {
        ((BoundBoxPy*)self)->setYMax(Py::Float(value,false));
        return 0;
    } catch (const Py::Exception&) {
        // The exception text is already set
        return -1;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'YMax' of object 'BoundBox'");
        return -1;
    }
}

// ZMax() callback and implementer
// PyObject*  BoundBoxPy::ZMax(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getZMax (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getZMax());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'ZMax' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setZMax (PyObject *self, PyObject *value, void * /*closure*/)
{    
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
        return -1;
    }

    try {
        ((BoundBoxPy*)self)->setZMax(Py::Float(value,false));
        return 0;
    } catch (const Py::Exception&) {
        // The exception text is already set
        return -1;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'ZMax' of object 'BoundBox'");
        return -1;
    }
}

// XMin() callback and implementer
// PyObject*  BoundBoxPy::XMin(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getXMin (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getXMin());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'XMin' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setXMin (PyObject *self, PyObject *value, void * /*closure*/)
{    
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
        return -1;
    }

    try {
        ((BoundBoxPy*)self)->setXMin(Py::Float(value,false));
        return 0;
    } catch (const Py::Exception&) {
        // The exception text is already set
        return -1;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'XMin' of object 'BoundBox'");
        return -1;
    }
}

// YMin() callback and implementer
// PyObject*  BoundBoxPy::YMin(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getYMin (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getYMin());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'YMin' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setYMin (PyObject *self, PyObject *value, void * /*closure*/)
{    
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
        return -1;
    }

    try {
        ((BoundBoxPy*)self)->setYMin(Py::Float(value,false));
        return 0;
    } catch (const Py::Exception&) {
        // The exception text is already set
        return -1;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'YMin' of object 'BoundBox'");
        return -1;
    }
}

// ZMin() callback and implementer
// PyObject*  BoundBoxPy::ZMin(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getZMin (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getZMin());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'ZMin' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setZMin (PyObject *self, PyObject *value, void * /*closure*/)
{    
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
        return -1;
    }

    try {
        ((BoundBoxPy*)self)->setZMin(Py::Float(value,false));
        return 0;
    } catch (const Py::Exception&) {
        // The exception text is already set
        return -1;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'ZMin' of object 'BoundBox'");
        return -1;
    }
}

// XLength() callback and implementer
// PyObject*  BoundBoxPy::XLength(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getXLength (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getXLength());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'XLength' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setXLength (PyObject *self, PyObject * /*value*/, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }

    PyErr_SetString(PyExc_AttributeError, "Attribute 'XLength' of object 'BoundBox' is read-only");
    return -1;
}

// YLength() callback and implementer
// PyObject*  BoundBoxPy::YLength(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getYLength (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getYLength());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'YLength' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setYLength (PyObject *self, PyObject * /*value*/, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }

    PyErr_SetString(PyExc_AttributeError, "Attribute 'YLength' of object 'BoundBox' is read-only");
    return -1;
}

// ZLength() callback and implementer
// PyObject*  BoundBoxPy::ZLength(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getZLength (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getZLength());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'ZLength' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setZLength (PyObject *self, PyObject * /*value*/, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }

    PyErr_SetString(PyExc_AttributeError, "Attribute 'ZLength' of object 'BoundBox' is read-only");
    return -1;
}

// DiagonalLength() callback and implementer
// PyObject*  BoundBoxPy::DiagonalLength(PyObject *args){};
// has to be implemented in BoundBoxPyImp.cpp
PyObject * BoundBoxPy::staticCallback_getDiagonalLength (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((BoundBoxPy*)self)->getDiagonalLength());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'DiagonalLength' of object 'BoundBox'");
        return NULL;
    }
}

int BoundBoxPy::staticCallback_setDiagonalLength (PyObject *self, PyObject * /*value*/, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }

    PyErr_SetString(PyExc_AttributeError, "Attribute 'DiagonalLength' of object 'BoundBox' is read-only");
    return -1;
}



//--------------------------------------------------------------------------
// Parents structure
//--------------------------------------------------------------------------
PyParentObject BoundBoxPy::Parents[] = { PARENTSBaseBoundBoxPy };

//--------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------
BoundBoxPy::BoundBoxPy(BoundBox3d *pcObject, PyTypeObject *T)
    : PyObjectBase(reinterpret_cast<PyObjectBase::PointerType>(pcObject), T)
{
}


//--------------------------------------------------------------------------
// destructor
//--------------------------------------------------------------------------
BoundBoxPy::~BoundBoxPy()                                // Everything handled in parent
{
    // delete the handled object when the PyObject dies
    BoundBoxPy::PointerType ptr = reinterpret_cast<BoundBoxPy::PointerType>(_pcTwinPointer);
    delete ptr;
}

//--------------------------------------------------------------------------
// BoundBoxPy representation
//--------------------------------------------------------------------------
PyObject *BoundBoxPy::_repr(void)
{
    return Py_BuildValue("s", representation().c_str());
}

//--------------------------------------------------------------------------
// BoundBoxPy Attributes
//--------------------------------------------------------------------------
PyObject *BoundBoxPy::_getattr(char *attr)                              // __getattr__ function: note only need to handle new state
{
    try {
        // getter method for special Attributes (e.g. dynamic ones)
        PyObject *r = getCustomAttributes(attr);
        if(r) return r;
    }
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return NULL;
    }
#else  // DONT_CATCH_CXX_EXCEPTIONS  
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
#endif  // DONT_CATCH_CXX_EXCEPTIONS

    PyObject *rvalue = Py_FindMethod(Methods, this, attr);
    if (rvalue == NULL)
    {
        PyErr_Clear();
        return PyObjectBase::_getattr(attr);
    }
    else
    {
        return rvalue;
    }
}

int BoundBoxPy::_setattr(char *attr, PyObject *value)   // __setattr__ function: note only need to handle new state
{
    try {
        // setter for  special Attributes (e.g. dynamic ones)
        int r = setCustomAttributes(attr, value);
        if(r==1) return 0;
    }
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return -1;
    }
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return -1;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return -1;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return -1;
    }
#else  // DONT_CATCH_CXX_EXCEPTIONS  
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return -1;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return -1;
    }
#endif  // DONT_CATCH_CXX_EXCEPTIONS

    return PyObjectBase::_setattr(attr, value);
}

BoundBox3d *BoundBoxPy::getBoundBoxPtr(void) const
{
    return static_cast<BoundBox3d *>(_pcTwinPointer);
}

#if 0
/* From here on come the methods you have to implement, but NOT in this module. Implement in BoundBoxPyImp.cpp! This prototypes 
 * are just for convenience when you add a new method.
 */

PyObject *BoundBoxPy::PyMake(struct _typeobject *, PyObject *, PyObject *)  // Python wrapper
{
    // create a new instance of BoundBoxPy and the Twin object 
    return new BoundBoxPy(new BoundBox3d);
}

// constructor method
int BoundBoxPy::PyInit(PyObject* /*args*/, PyObject* /*kwd*/)
{
    return 0;
}

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

PyObject* BoundBoxPy::add(PyObject *args)
{
    PyErr_SetString(PyExc_NotImplementedError, "Not yet implemented");
    return 0;
}

PyObject* BoundBoxPy::isIntersection(PyObject *args)
{
    PyErr_SetString(PyExc_NotImplementedError, "Not yet implemented");
    return 0;
}

PyObject* BoundBoxPy::enlarge(PyObject *args)
{
    PyErr_SetString(PyExc_NotImplementedError, "Not yet implemented");
    return 0;
}

PyObject* BoundBoxPy::getIntersectionPoint(PyObject *args)
{
    PyErr_SetString(PyExc_NotImplementedError, "Not yet implemented");
    return 0;
}

PyObject* BoundBoxPy::move(PyObject *args)
{
    PyErr_SetString(PyExc_NotImplementedError, "Not yet implemented");
    return 0;
}

PyObject* BoundBoxPy::isCutPlane(PyObject *args)
{
    PyErr_SetString(PyExc_NotImplementedError, "Not yet implemented");
    return 0;
}

PyObject* BoundBoxPy::isInside(PyObject *args)
{
    PyErr_SetString(PyExc_NotImplementedError, "Not yet implemented");
    return 0;
}



Py::Object BoundBoxPy::getCenter(void) const
{
    //return Py::Object();
    throw Py::AttributeError("Not yet implemented");
}

Py::Float BoundBoxPy::getXMax(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

void  BoundBoxPy::setXMax(Py::Float arg)
{
    throw Py::AttributeError("Not yet implemented");
}

Py::Float BoundBoxPy::getYMax(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

void  BoundBoxPy::setYMax(Py::Float arg)
{
    throw Py::AttributeError("Not yet implemented");
}

Py::Float BoundBoxPy::getZMax(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

void  BoundBoxPy::setZMax(Py::Float arg)
{
    throw Py::AttributeError("Not yet implemented");
}

Py::Float BoundBoxPy::getXMin(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

void  BoundBoxPy::setXMin(Py::Float arg)
{
    throw Py::AttributeError("Not yet implemented");
}

Py::Float BoundBoxPy::getYMin(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

void  BoundBoxPy::setYMin(Py::Float arg)
{
    throw Py::AttributeError("Not yet implemented");
}

Py::Float BoundBoxPy::getZMin(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

void  BoundBoxPy::setZMin(Py::Float arg)
{
    throw Py::AttributeError("Not yet implemented");
}

Py::Float BoundBoxPy::getXLength(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

Py::Float BoundBoxPy::getYLength(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

Py::Float BoundBoxPy::getZLength(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

Py::Float BoundBoxPy::getDiagonalLength(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

PyObject *BoundBoxPy::getCustomAttributes(const char* attr) const
{
    return 0;
}

int BoundBoxPy::setCustomAttributes(const char* attr, PyObject *obj)
{
    return 0; 
}
#endif