/***************************************************************************
 *   Copyright (c) 2007 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 "PreCompiled.h"

#include <Base/Converter.h>
#include <Base/GeometryPyCXX.h>
#include <Base/MatrixPy.h>
#include <Base/PyWrapParseTupleAndKeywords.h>
#include <Base/Stream.h>
#include <Base/Tools.h>
#include <Base/VectorPy.h>

#include <boost/algorithm/string.hpp>

#include "Core/Degeneration.h"
#include "Core/Segmentation.h"
#include "Core/Smoothing.h"
#include "Core/Triangulation.h"

#include "Mesh.h"
#include "MeshPy.h"
#include "MeshPointPy.h"
#include "FacetPy.h"
#include "MeshPy.cpp"
#include "MeshProperties.h"


using namespace Mesh;


struct MeshPropertyLock {
    explicit MeshPropertyLock(PropertyMeshKernel* p) : prop(p)
    { if (prop) prop->startEditing(); }
    ~MeshPropertyLock()
    { if (prop) prop->finishEditing(); }
private:
    PropertyMeshKernel* prop;
};

int MeshPy::PyInit(PyObject* args, PyObject*)
{
    PyObject *pcObj=nullptr;
    if (!PyArg_ParseTuple(args, "|O", &pcObj))
        return -1;

    try {
        this->parentProperty = nullptr;
        // if no mesh is given
        if (!pcObj)
            return 0;
        if (PyObject_TypeCheck(pcObj, &(MeshPy::Type))) {
            getMeshObjectPtr()->operator = (*static_cast<MeshPy*>(pcObj)->getMeshObjectPtr());
        }
        else if (PyList_Check(pcObj)) {
            PyObject* ret = addFacets(args);
            bool ok = (ret != nullptr);
            Py_XDECREF(ret);
            if (!ok)
                return -1;
        }
        else if (PyTuple_Check(pcObj)) {
            PyObject* ret = addFacets(args);
            bool ok = (ret != nullptr);
            Py_XDECREF(ret);
            if (!ok)
                return -1;
        }
        else if (PyUnicode_Check(pcObj)) {
            getMeshObjectPtr()->load(PyUnicode_AsUTF8(pcObj));
        }
        else {
            PyErr_Format(PyExc_TypeError, "Cannot create a mesh out of a '%s'",
                pcObj->ob_type->tp_name);
            return -1;
        }
    }
    catch (const Base::Exception &e) {
        e.setPyException();
        return -1;
    }
    catch (const std::exception &e) {
        PyErr_SetString(Base::PyExc_FC_GeneralError,e.what());
        return -1;
    }
    catch (const Py::Exception&) {
        return -1;
    }

    return 0;
}

// returns a string which represent the object e.g. when printed in python
std::string MeshPy::representation() const
{
    return getMeshObjectPtr()->representation();
}

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

PyObject* MeshPy::copy(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    return new MeshPy(new MeshObject(*getMeshObjectPtr()));
}

PyObject*  MeshPy::read(PyObject *args, PyObject *kwds)
{
    char* Name;
    static const std::array<const char *, 2> keywords_path {"Filename",nullptr};
    if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "et", keywords_path, "utf-8", &Name)) {
        getMeshObjectPtr()->load(Name);
        PyMem_Free(Name);
        Py_Return;
    }

    PyErr_Clear();

    MeshCore::MeshIO::Format format = MeshCore::MeshIO::Undefined;
    std::map<std::string, MeshCore::MeshIO::Format> ext;
    ext["BMS" ] = MeshCore::MeshIO::BMS;
    ext["STL" ] = MeshCore::MeshIO::BSTL;
    ext["AST" ] = MeshCore::MeshIO::ASTL;
    ext["OBJ" ] = MeshCore::MeshIO::OBJ;
    ext["SMF" ] = MeshCore::MeshIO::SMF;
    ext["OFF" ] = MeshCore::MeshIO::OFF;
    ext["IV"  ] = MeshCore::MeshIO::IV;
    ext["X3D" ] = MeshCore::MeshIO::X3D;
    ext["X3DZ"] = MeshCore::MeshIO::X3DZ;
    ext["VRML"] = MeshCore::MeshIO::VRML;
    ext["WRL" ] = MeshCore::MeshIO::VRML;
    ext["WRZ" ] = MeshCore::MeshIO::WRZ;
    ext["NAS" ] = MeshCore::MeshIO::NAS;
    ext["BDF" ] = MeshCore::MeshIO::NAS;
    ext["PLY" ] = MeshCore::MeshIO::PLY;
    ext["APLY"] = MeshCore::MeshIO::APLY;
    ext["PY"  ] = MeshCore::MeshIO::PY;

    PyObject* input;
    char* Ext;
    static const std::array<const char *, 3> keywords_stream {"Stream", "Format", nullptr};
    if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "Os",keywords_stream, &input, &Ext)) {
        std::string fmt(Ext);
        boost::to_upper(fmt);
        if (ext.find(fmt) != ext.end()) {
            format = ext[fmt];
        }

        // read mesh
        Base::PyStreambuf buf(input);
        std::istream str(nullptr);
        str.rdbuf(&buf);
        getMeshObjectPtr()->load(str, format);

        Py_Return;
    }

    PyErr_SetString(PyExc_TypeError, "expect string or file object");
    return nullptr;
}

PyObject*  MeshPy::write(PyObject *args, PyObject *kwds)
{
    char* Name;
    char* Ext=nullptr;
    char* ObjName=nullptr;
    PyObject* List=nullptr;

    MeshCore::MeshIO::Format format = MeshCore::MeshIO::Undefined;
    std::map<std::string, MeshCore::MeshIO::Format> ext;
    ext["BMS"  ] = MeshCore::MeshIO::BMS;
    ext["STL"  ] = MeshCore::MeshIO::BSTL;
    ext["AST"  ] = MeshCore::MeshIO::ASTL;
    ext["OBJ"  ] = MeshCore::MeshIO::OBJ;
    ext["SMF"  ] = MeshCore::MeshIO::SMF;
    ext["OFF"  ] = MeshCore::MeshIO::OFF;
    ext["IDTF" ] = MeshCore::MeshIO::IDTF;
    ext["MGL"  ] = MeshCore::MeshIO::MGL;
    ext["IV"   ] = MeshCore::MeshIO::IV;
    ext["X3D"  ] = MeshCore::MeshIO::X3D;
    ext["X3DZ" ] = MeshCore::MeshIO::X3DZ;
    ext["X3DOM"] = MeshCore::MeshIO::X3DOM;
    ext["VRML" ] = MeshCore::MeshIO::VRML;
    ext["WRL"  ] = MeshCore::MeshIO::VRML;
    ext["WRZ"  ] = MeshCore::MeshIO::WRZ;
    ext["NAS"  ] = MeshCore::MeshIO::NAS;
    ext["BDF"  ] = MeshCore::MeshIO::NAS;
    ext["PLY"  ] = MeshCore::MeshIO::PLY;
    ext["APLY" ] = MeshCore::MeshIO::APLY;
    ext["PY"   ] = MeshCore::MeshIO::PY;
    ext["ASY"  ] = MeshCore::MeshIO::ASY;
    ext["3MF"  ] = MeshCore::MeshIO::ThreeMF;

    static const std::array<const char *, 5> keywords_path {"Filename","Format","Name","Material",nullptr};
    if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "et|ssO", keywords_path, "utf-8",
                                            &Name, &Ext, &ObjName, &List)) {
        if (Ext) {
            std::string fmt(Ext);
            boost::to_upper(fmt);
            if (ext.find(fmt) != ext.end()) {
                format = ext[fmt];
            }
        }

        if (List) {
            MeshCore::Material mat;
            Py::Sequence list(List);
            for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
                Py::Tuple t(*it);
                float r = (float)Py::Float(t.getItem(0));
                float g = (float)Py::Float(t.getItem(1));
                float b = (float)Py::Float(t.getItem(2));
                mat.diffuseColor.emplace_back(r,g,b);
            }

            if (mat.diffuseColor.size() == getMeshObjectPtr()->countPoints())
                mat.binding = MeshCore::MeshIO::PER_VERTEX;
            else if (mat.diffuseColor.size() == getMeshObjectPtr()->countFacets())
                mat.binding = MeshCore::MeshIO::PER_FACE;
            else
                mat.binding = MeshCore::MeshIO::OVERALL;
            getMeshObjectPtr()->save(Name, format, &mat, ObjName);
        }
        else {
            getMeshObjectPtr()->save(Name, format, nullptr, ObjName);
        }

        PyMem_Free(Name);
        Py_Return;
    }

    PyErr_Clear();

    static const std::array<const char *, 5> keywords_stream {"Stream", "Format", "Name", "Material", nullptr};
    PyObject* input;
    if (Base::Wrapped_ParseTupleAndKeywords(args, kwds, "Os|sO", keywords_stream,
                                            &input, &Ext, &ObjName, &List)) {
        std::string fmt(Ext);
        boost::to_upper(fmt);
        if (ext.find(fmt) != ext.end()) {
            format = ext[fmt];
        }

        std::unique_ptr<MeshCore::Material> mat;
        if (List) {
            mat = std::make_unique<MeshCore::Material>();
            Py::Sequence list(List);
            for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
                Py::Tuple t(*it);
                float r = (float)Py::Float(t.getItem(0));
                float g = (float)Py::Float(t.getItem(1));
                float b = (float)Py::Float(t.getItem(2));
                mat->diffuseColor.emplace_back(r,g,b);
            }

            if (mat->diffuseColor.size() == getMeshObjectPtr()->countPoints())
                mat->binding = MeshCore::MeshIO::PER_VERTEX;
            else if (mat->diffuseColor.size() == getMeshObjectPtr()->countFacets())
                mat->binding = MeshCore::MeshIO::PER_FACE;
            else
                mat->binding = MeshCore::MeshIO::OVERALL;
        }

        // write mesh
        Base::PyStreambuf buf(input);
        std::ostream str(nullptr);
        str.rdbuf(&buf);
        getMeshObjectPtr()->save(str, format, mat.get(), ObjName);

        Py_Return;
    }

    PyErr_SetString(PyExc_TypeError, "expect string or file object");
    return nullptr;
}

PyObject*  MeshPy::writeInventor(PyObject *args)
{
    float creaseangle=0.0f;
    if (!PyArg_ParseTuple(args, "|f",&creaseangle))
        return nullptr;

    std::stringstream result;
    MeshObject* mesh = getMeshObjectPtr();
    mesh->writeInventor(result, creaseangle);
    return Py::new_reference_to(Py::String(result.str()));
}

PyObject*  MeshPy::offset(PyObject *args)
{
    float Float;
    if (!PyArg_ParseTuple(args, "f",&Float))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->offsetSpecial2(Float);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::offsetSpecial(PyObject *args)
{
    float Float,zmin,zmax;
    if (!PyArg_ParseTuple(args, "fff",&Float,&zmin,&zmax))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->offsetSpecial(Float,zmax,zmin);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::crossSections(PyObject *args)
{
    PyObject *obj;
    PyObject *poly=Py_False;
    float min_eps = 1.0e-2f;
    if (!PyArg_ParseTuple(args, "O|fO!", &obj, &min_eps, &PyBool_Type, &poly))
        return nullptr;

    Py::Sequence list(obj);
    Py::Type vType(Base::getTypeAsObject(&Base::VectorPy::Type));

    std::vector<MeshObject::TPlane> csPlanes;
    for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
        Py::Tuple pair(*it);
        Py::Object p1 = pair.getItem(0);
        Py::Object p2 = pair.getItem(1);
        if (p1.isType(vType) && p2.isType(vType)) {
            MeshObject::TPlane plane;
            Base::Vector3d b = static_cast<Base::VectorPy*>(p1.ptr())->value();
            Base::Vector3d n = static_cast<Base::VectorPy*>(p2.ptr())->value();
            plane.first.Set((float)b.x,(float)b.y,(float)b.z);
            plane.second.Set((float)n.x,(float)n.y,(float)n.z);
            csPlanes.push_back(plane);
        }
        else if (p1.isTuple() && p2.isTuple()) {
            Py::Tuple b(p1);
            Py::Tuple n(p2);
            float bx = (float)Py::Float(b.getItem(0));
            float by = (float)Py::Float(b.getItem(1));
            float bz = (float)Py::Float(b.getItem(2));
            float nx = (float)Py::Float(n.getItem(0));
            float ny = (float)Py::Float(n.getItem(1));
            float nz = (float)Py::Float(n.getItem(2));

            MeshObject::TPlane plane;
            plane.first .Set(bx,by,bz);
            plane.second.Set(nx,ny,nz);
            csPlanes.push_back(plane);
        }
    }

    std::vector<MeshObject::TPolylines> sections;
    getMeshObjectPtr()->crossSections(csPlanes, sections, min_eps, Base::asBoolean(poly));

    // convert to Python objects
    Py::List crossSections;
    for (const auto & it : sections) {
        Py::List section;
        for (const auto & jt : it) {
            Py::List polyline;
            for (auto kt : jt) {
                polyline.append(Py::asObject(new Base::VectorPy(kt)));
            }
            section.append(polyline);
        }
        crossSections.append(section);
    }

    return Py::new_reference_to(crossSections);
}

PyObject*  MeshPy::unite(PyObject *args)
{
    MeshPy   *pcObject;
    PyObject *pcObj;
    if (!PyArg_ParseTuple(args, "O!", &(MeshPy::Type), &pcObj))
        return nullptr;

    pcObject = static_cast<MeshPy*>(pcObj);

    PY_TRY {
        MeshObject* mesh = getMeshObjectPtr()->unite(*pcObject->getMeshObjectPtr());
        return new MeshPy(mesh);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::intersect(PyObject *args)
{
    MeshPy   *pcObject;
    PyObject *pcObj;
    if (!PyArg_ParseTuple(args, "O!", &(MeshPy::Type), &pcObj))
        return nullptr;

    pcObject = static_cast<MeshPy*>(pcObj);

    PY_TRY {
        MeshObject* mesh = getMeshObjectPtr()->intersect(*pcObject->getMeshObjectPtr());
        return new MeshPy(mesh);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::difference(PyObject *args)
{
    MeshPy   *pcObject;
    PyObject *pcObj;
    if (!PyArg_ParseTuple(args, "O!", &(MeshPy::Type), &pcObj))
        return nullptr;

    pcObject = static_cast<MeshPy*>(pcObj);

    PY_TRY {
        MeshObject* mesh = getMeshObjectPtr()->subtract(*pcObject->getMeshObjectPtr());
        return new MeshPy(mesh);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::inner(PyObject *args)
{
    MeshPy   *pcObject;
    PyObject *pcObj;
    if (!PyArg_ParseTuple(args, "O!", &(MeshPy::Type), &pcObj))
        return nullptr;

    pcObject = static_cast<MeshPy*>(pcObj);

    PY_TRY {
        MeshObject* mesh = getMeshObjectPtr()->inner(*pcObject->getMeshObjectPtr());
        return new MeshPy(mesh);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::outer(PyObject *args)
{
    MeshPy   *pcObject;
    PyObject *pcObj;
    if (!PyArg_ParseTuple(args, "O!", &(MeshPy::Type), &pcObj))
        return nullptr;

    pcObject = static_cast<MeshPy*>(pcObj);

    PY_TRY {
        MeshObject* mesh = getMeshObjectPtr()->outer(*pcObject->getMeshObjectPtr());
        return new MeshPy(mesh);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::section(PyObject *args, PyObject *kwds)
{
    PyObject *pcObj;
    PyObject *connectLines = Py_True;
    float fMinDist = 0.0001f;

    static const std::array<const char *, 4> keywords_section {"Mesh", "ConnectLines", "MinDist", nullptr};
    if (!Base::Wrapped_ParseTupleAndKeywords(args, kwds, "O!|O!f",keywords_section,
                                     &(MeshPy::Type), &pcObj, &PyBool_Type, &connectLines, &fMinDist)) {
        return nullptr;
    }

    MeshPy* pcObject = static_cast<MeshPy*>(pcObj);

    std::vector< std::vector<Base::Vector3f> > curves = getMeshObjectPtr()->section(*pcObject->getMeshObjectPtr(), Base::asBoolean(connectLines), fMinDist);
    Py::List outer;
    for (const auto& it : curves) {
        Py::List inner;
        for (const auto& jt : it) {
            inner.append(Py::Vector(jt));
        }
        outer.append(inner);
    }

    return Py::new_reference_to(outer);
}

PyObject*  MeshPy::coarsen(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    PyErr_SetString(PyExc_NotImplementedError, "Not yet implemented");
    return nullptr;
}

PyObject*  MeshPy::translate(PyObject *args)
{
    float x,y,z;
    if (!PyArg_ParseTuple(args, "fff",&x,&y,&z))
        return nullptr;

    PY_TRY {
        Base::Matrix4D m;
        m.move(x,y,z);
        getMeshObjectPtr()->getKernel().Transform(m);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::rotate(PyObject *args)
{
    double x,y,z;
    if (!PyArg_ParseTuple(args, "ddd",&x,&y,&z))
        return nullptr;

    PY_TRY {
        Base::Matrix4D m;
        m.rotX(x);
        m.rotY(y);
        m.rotZ(z);
        getMeshObjectPtr()->getKernel().Transform(m);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::transform(PyObject *args)
{
    PyObject *mat;
    if (!PyArg_ParseTuple(args, "O!",&(Base::MatrixPy::Type), &mat))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->getKernel().Transform(static_cast<Base::MatrixPy*>(mat)->value());
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::transformToEigen(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    getMeshObjectPtr()->transformToEigenSystem();
    Py_Return;
}

PyObject*  MeshPy::getEigenSystem(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    Base::Vector3d vec;
    Base::Matrix4D mat = getMeshObjectPtr()->getEigenSystem(vec);
    Py::Tuple t(2);
    t.setItem(0, Py::Matrix(mat));
    t.setItem(1, Py::Vector(vec));
    return Py::new_reference_to(t);
}

PyObject*  MeshPy::addFacet(PyObject *args)
{
    double x1,y1,z1,x2,y2,z2,x3,y3,z3;
    if (PyArg_ParseTuple(args, "ddddddddd",&x1,&y1,&z1,&x2,&y2,&z2,&x3,&y3,&z3)) {
        getMeshObjectPtr()->addFacet(MeshCore::MeshGeomFacet(
                        Base::Vector3f((float)x1,(float)y1,(float)z1),
                        Base::Vector3f((float)x2,(float)y2,(float)z2),
                        Base::Vector3f((float)x3,(float)y3,(float)z3)));
        Py_Return;
    }

    PyErr_Clear();
    PyObject *v1, *v2, *v3;
    if (PyArg_ParseTuple(args, "O!O!O!",&(Base::VectorPy::Type), &v1,
                                        &(Base::VectorPy::Type), &v2,
                                        &(Base::VectorPy::Type), &v3)) {
        Base::Vector3d *p1 = static_cast<Base::VectorPy*>(v1)->getVectorPtr();
        Base::Vector3d *p2 = static_cast<Base::VectorPy*>(v2)->getVectorPtr();
        Base::Vector3d *p3 = static_cast<Base::VectorPy*>(v3)->getVectorPtr();
        getMeshObjectPtr()->addFacet(MeshCore::MeshGeomFacet(
                        Base::Vector3f((float)p1->x,(float)p1->y,(float)p1->z),
                        Base::Vector3f((float)p2->x,(float)p2->y,(float)p2->z),
                        Base::Vector3f((float)p3->x,(float)p3->y,(float)p3->z)));
        Py_Return;
    }

    PyErr_Clear();
    PyObject *f;
    if (PyArg_ParseTuple(args, "O!",&(Mesh::FacetPy::Type), &f)) {
        Mesh::FacetPy* face = static_cast<Mesh::FacetPy*>(f);
        getMeshObjectPtr()->addFacet(*face->getFacetPtr());
        Py_Return;
    }

    PyErr_SetString(PyExc_TypeError, "set 9 floats or three vectors or a facet");
    return nullptr;
}

PyObject*  MeshPy::addFacets(PyObject *args)
{
    PyObject *list;
    if (PyArg_ParseTuple(args, "O!", &PyList_Type, &list)) {
        Py::List list_f(list);
        Py::Type vVType(Base::getTypeAsObject(&Base::VectorPy::Type));
        Py::Type vFType(Base::getTypeAsObject(&Mesh::FacetPy::Type));

        std::vector<MeshCore::MeshGeomFacet> facets;
        MeshCore::MeshGeomFacet facet;
        for (Py::List::iterator it = list_f.begin(); it != list_f.end(); ++it) {
            if ((*it).isType(vFType)) {
                Mesh::FacetPy* face = static_cast<Mesh::FacetPy*>((*it).ptr());
                facets.push_back(*face->getFacetPtr());
            }
            else if ((*it).isSequence()) {
                Py::Sequence seq(*it);
                if (seq.size() == 3) {
                    if (PyFloat_Check(seq[0].ptr())) {
                        // every three triples build a triangle
                        facet._aclPoints[0] = Base::getVectorFromTuple<float>((*it).ptr());
                        ++it;
                        facet._aclPoints[1] = Base::getVectorFromTuple<float>((*it).ptr());
                        ++it;
                        facet._aclPoints[2] = Base::getVectorFromTuple<float>((*it).ptr());
                    }
                    else if (seq[0].isSequence()) {
                        // a sequence of sequence of flots
                        for (int i=0; i<3; i++) {
                            facet._aclPoints[i] = Base::getVectorFromTuple<float>(seq[i].ptr());
                        }
                    }
                    else if (PyObject_TypeCheck(seq[0].ptr(), &(Base::VectorPy::Type))) {
                        // a sequence of vectors
                        for (int i=0; i<3; i++) {
                            Base::Vector3d p = Py::Vector(seq[i]).toVector();
                            facet._aclPoints[i].Set((float)p.x,(float)p.y,(float)p.z);
                        }
                    }
                    else {
                        PyErr_SetString(PyExc_TypeError, "expect a sequence of floats or Vector");
                        return nullptr;
                    }

                    facet.CalcNormal();
                    facets.push_back(facet);
                }
                else {
                    // 9 consecutive floats expected
                    int index=0;
                    for (auto & point : facet._aclPoints) {
                        point.x = (float)(double)Py::Float(seq[index++]);
                        point.y = (float)(double)Py::Float(seq[index++]);
                        point.z = (float)(double)Py::Float(seq[index++]);
                    }
                    facet.CalcNormal();
                    facets.push_back(facet);
                }
            } // sequence
        }

        getMeshObjectPtr()->addFacets(facets);
        Py_Return;
    }

    PyErr_Clear();
    PyObject *check = Py_True;
    if (PyArg_ParseTuple(args, "O!|O!", &PyTuple_Type, &list, &PyBool_Type, &check)) {
        Py::Tuple tuple(list);
        Py::List list_v(tuple.getItem(0));
        std::vector<Base::Vector3f> vertices;
        Py::Type vType(Base::getTypeAsObject(&Base::VectorPy::Type));
        for (Py::List::iterator it = list_v.begin(); it != list_v.end(); ++it) {
            if ((*it).isType(vType)) {
                Base::Vector3d v = static_cast<Base::VectorPy*>((*it).ptr())->value();
                vertices.emplace_back((float)v.x,(float)v.y,(float)v.z);
            }
        }

        Py::List list_f(tuple.getItem(1));
        MeshCore::MeshFacetArray faces;
        for (Py::List::iterator it = list_f.begin(); it != list_f.end(); ++it) {
            Py::Tuple f(*it);
            MeshCore::MeshFacet face;
            face._aulPoints[0] = static_cast<long>(Py::Long(f.getItem(0)));
            face._aulPoints[1] = static_cast<long>(Py::Long(f.getItem(1)));
            face._aulPoints[2] = static_cast<long>(Py::Long(f.getItem(2)));
            faces.push_back(face);
        }

        getMeshObjectPtr()->addFacets(faces, vertices, Base::asBoolean(check));

        Py_Return;
    }

    PyErr_SetString(PyExc_TypeError, "either expect\n"
        "-- [Vector] (3 of them define a facet)\n"
        "-- ([Vector],[(int,int,int)])");
    return nullptr;
}

PyObject* MeshPy::removeFacets(PyObject *args)
{
    PyObject* list;
    if (!PyArg_ParseTuple(args, "O", &list))
        return nullptr;

    std::vector<FacetIndex> indices;
    Py::Sequence ary(list);
    for (Py::Sequence::iterator it = ary.begin(); it != ary.end(); ++it) {
        Py::Long f(*it);
        indices.push_back((long)f);
    }

    getMeshObjectPtr()->deleteFacets(indices);
    Py_Return;
}

PyObject* MeshPy::getInternalFacets(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    const MeshCore::MeshKernel& kernel = getMeshObjectPtr()->getKernel();
    MeshCore::MeshEvalInternalFacets eval(kernel);
    eval.Evaluate();

    const std::vector<FacetIndex>& indices = eval.GetIndices();
    Py::List ary(indices.size());
    Py::List::size_type pos=0;
    for (FacetIndex index : indices) {
        ary[pos++] = Py::Long(index);
    }

    return Py::new_reference_to(ary);
}

PyObject* MeshPy::rebuildNeighbourHood(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    MeshCore::MeshKernel& kernel = getMeshObjectPtr()->getKernel();
    kernel.RebuildNeighbours();
    Py_Return;
}

PyObject*  MeshPy::addMesh(PyObject *args)
{
    PyObject* mesh;
    if (!PyArg_ParseTuple(args, "O!",&(MeshPy::Type), &mesh))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->addMesh(*static_cast<MeshPy*>(mesh)->getMeshObjectPtr());
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::setPoint(PyObject *args)
{
    unsigned long index;
    PyObject* pnt;
    if (!PyArg_ParseTuple(args, "kO!",&index, &(Base::VectorPy::Type), &pnt))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->setPoint(index, static_cast<Base::VectorPy*>(pnt)->value());
    } PY_CATCH;

    Py_Return;
}

PyObject* MeshPy::movePoint(PyObject *args)
{
    unsigned long index;
    Base::Vector3d vec;

    do {
        double  x=0.0,y=0.0,z=0.0;
        if (PyArg_ParseTuple(args, "kddd", &index,&x,&y,&z)) {
            vec.Set(x,y,z);
            break;
        }

        PyErr_Clear(); // set by PyArg_ParseTuple()
        PyObject *object;
        if (PyArg_ParseTuple(args,"kO!", &index, &(Base::VectorPy::Type), &object)) {
            vec = *(static_cast<Base::VectorPy*>(object)->getVectorPtr());
            break;
        }

        PyErr_SetString(PyExc_TypeError, "Tuple of three floats or Vector expected");
        return nullptr;
    }
    while (false);

    getMeshObjectPtr()->movePoint(index, vec);
    Py_Return;
}

PyObject*  MeshPy::getPointNormals(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        std::vector<Base::Vector3d> normals = getMeshObjectPtr()->getPointNormals();
        Py::Tuple ary(normals.size());
        std::size_t numNormals = normals.size();
        for (std::size_t i=0; i<numNormals; i++) {
            ary.setItem(i, Py::Vector(normals[i]));
        }
        return Py::new_reference_to(ary);
    } PY_CATCH;
}

PyObject* MeshPy::addSegment(PyObject *args)
{
    PyObject* pylist;
    if (!PyArg_ParseTuple(args, "O", &pylist))
        return nullptr;

    Py::Sequence list(pylist);
    std::vector<Mesh::FacetIndex> segment;
    unsigned long numFacets = getMeshObjectPtr()->countFacets();
    segment.reserve(list.size());
    for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
        Py::Long value(*it);
        Mesh::FacetIndex index = static_cast<unsigned long>(value);
        if (index < numFacets)
            segment.push_back(index);
    }

    getMeshObjectPtr()->addSegment(segment);
    Py_Return;
}

PyObject* MeshPy::countSegments(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    unsigned long count = getMeshObjectPtr()->countSegments();
    return Py_BuildValue("k",count);
}

PyObject* MeshPy::getSegment(PyObject *args)
{
    unsigned long index;
    if (!PyArg_ParseTuple(args, "k", &index))
        return nullptr;

    unsigned long count = getMeshObjectPtr()->countSegments();
    if (index >= count) {
        PyErr_SetString(PyExc_IndexError, "index out of range");
        return nullptr;
    }

    Py::List ary;
    const std::vector<FacetIndex>& segm = getMeshObjectPtr()->getSegment(index).getIndices();
    for (FacetIndex it : segm) {
        ary.append(Py::Long(it));
    }

    return Py::new_reference_to(ary);
}

PyObject* MeshPy::getSeparateComponents(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    Py::List meshesList;
    std::vector<std::vector<FacetIndex> > segs;
    segs = getMeshObjectPtr()->getComponents();
    for (const auto & it : segs) {
        MeshObject* mesh = getMeshObjectPtr()->meshFromSegment(it);
        meshesList.append(Py::Object(new MeshPy(mesh),true));
    }
    return Py::new_reference_to(meshesList);
}

PyObject* MeshPy::getFacetSelection(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    Py::List ary;
    std::vector<FacetIndex> facets;
    getMeshObjectPtr()->getFacetsFromSelection(facets);
    for (FacetIndex facet : facets) {
        ary.append(Py::Long(int(facet)));
    }

    return Py::new_reference_to(ary);
}

PyObject* MeshPy::getPointSelection(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    Py::List ary;
    std::vector<PointIndex> points;
    getMeshObjectPtr()->getPointsFromSelection(points);
    for (PointIndex point : points) {
        ary.append(Py::Long(int(point)));
    }

    return Py::new_reference_to(ary);
}

PyObject* MeshPy::meshFromSegment(PyObject *args)
{
    PyObject* list;
    if (!PyArg_ParseTuple(args, "O", &list))
        return nullptr;

    std::vector<FacetIndex> segment;
    Py::Sequence ary(list);
    for (Py::Sequence::iterator it = ary.begin(); it != ary.end(); ++it) {
        Py::Long f(*it);
        segment.push_back((long)f);
    }


    MeshObject* mesh = getMeshObjectPtr()->meshFromSegment(segment);
    return new MeshPy(mesh);
}

PyObject*  MeshPy::clear(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    getMeshObjectPtr()->clear();
    Py_Return;
}

PyObject*  MeshPy::isSolid(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    bool ok = getMeshObjectPtr()->isSolid();
    return Py_BuildValue("O", (ok ? Py_True : Py_False));
}

PyObject*  MeshPy::hasNonManifolds(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    bool ok = getMeshObjectPtr()->hasNonManifolds();
    return Py_BuildValue("O", (ok ? Py_True : Py_False));
}

PyObject*  MeshPy::hasInvalidNeighbourhood(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    bool ok = getMeshObjectPtr()->hasInvalidNeighbourhood();
    return Py_BuildValue("O", (ok ? Py_True : Py_False));
}

PyObject*  MeshPy::hasPointsOutOfRange(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    bool ok = getMeshObjectPtr()->hasPointsOutOfRange();
    return Py_BuildValue("O", (ok ? Py_True : Py_False));
}

PyObject*  MeshPy::hasFacetsOutOfRange(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    bool ok = getMeshObjectPtr()->hasFacetsOutOfRange();
    return Py_BuildValue("O", (ok ? Py_True : Py_False));
}

PyObject*  MeshPy::hasCorruptedFacets(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    bool ok = getMeshObjectPtr()->hasFacetsOutOfRange();
    return Py_BuildValue("O", (ok ? Py_True : Py_False));
}

PyObject*  MeshPy::removeNonManifolds(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    getMeshObjectPtr()->removeNonManifolds();
    Py_Return;
}

PyObject*  MeshPy::removeNonManifoldPoints(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    getMeshObjectPtr()->removeNonManifoldPoints();
    Py_Return;
}

PyObject*  MeshPy::hasSelfIntersections(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    bool ok = getMeshObjectPtr()->hasSelfIntersections();
    return Py_BuildValue("O", (ok ? Py_True : Py_False));
}

PyObject*  MeshPy::getSelfIntersections(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    std::vector<std::pair<FacetIndex, FacetIndex> > selfIndices;
    std::vector<Base::Line3d> selfLines;

    selfIndices = getMeshObjectPtr()->getSelfIntersections();
    selfLines = getMeshObjectPtr()->getSelfIntersections(selfIndices);

    Py::Tuple tuple(selfIndices.size());
    if (selfIndices.size() == selfLines.size()) {
        for (std::size_t i=0; i<selfIndices.size(); i++) {
            Py::Tuple item(4);
            item.setItem(0, Py::Long(selfIndices[i].first));
            item.setItem(1, Py::Long(selfIndices[i].second));
            item.setItem(2, Py::Vector(selfLines[i].p1));
            item.setItem(3, Py::Vector(selfLines[i].p2));
            tuple.setItem(i, item);
        }
    }

    return Py::new_reference_to(tuple);
}

PyObject*  MeshPy::fixSelfIntersections(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    try {
        getMeshObjectPtr()->removeSelfIntersections();
    }
    catch (const Base::Exception& e) {
        e.setPyException();
        return nullptr;
    }
    Py_Return;
}

PyObject*  MeshPy::removeFoldsOnSurface(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    try {
        getMeshObjectPtr()->removeFoldsOnSurface();
    }
    catch (const Base::Exception& e) {
        e.setPyException();
        return nullptr;
    }
    Py_Return;
}

PyObject*  MeshPy::hasInvalidPoints(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    bool ok = getMeshObjectPtr()->hasInvalidPoints();
    return Py_BuildValue("O", (ok ? Py_True : Py_False));
}

PyObject*  MeshPy::removeInvalidPoints(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    try {
        getMeshObjectPtr()->removeInvalidPoints();
    }
    catch (const Base::Exception& e) {
        e.setPyException();
        return nullptr;
    }
    Py_Return;
}

PyObject*  MeshPy::hasPointsOnEdge(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    bool ok = getMeshObjectPtr()->hasPointsOnEdge();
    return Py_BuildValue("O", (ok ? Py_True : Py_False));
}

PyObject*  MeshPy::removePointsOnEdge(PyObject *args, PyObject *kwds)
{
    PyObject *fillBoundary = Py_False; // NOLINT
    static const std::array<const char *, 2> keywords {"FillBoundary", nullptr};
    if (!Base::Wrapped_ParseTupleAndKeywords(args, kwds, "|O!", keywords, &PyBool_Type, &fillBoundary)) {
        return nullptr;
    }
    try {
        getMeshObjectPtr()->removePointsOnEdge(Base::asBoolean(fillBoundary));
    }
    catch (const Base::Exception& e) {
        e.setPyException();
        return nullptr;
    }
    Py_Return;
}

PyObject*  MeshPy::flipNormals(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        MeshPropertyLock lock(this->parentProperty);
        getMeshObjectPtr()->flipNormals();
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::hasNonUniformOrientedFacets(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    bool ok = getMeshObjectPtr()->countNonUniformOrientedFacets() > 0;
    return Py_BuildValue("O", (ok ? Py_True : Py_False));
}

PyObject*  MeshPy::countNonUniformOrientedFacets(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    unsigned long count = getMeshObjectPtr()->countNonUniformOrientedFacets();
    return Py_BuildValue("k", count);
}

PyObject*  MeshPy::getNonUniformOrientedFacets(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    const MeshCore::MeshKernel& kernel = getMeshObjectPtr()->getKernel();
    MeshCore::MeshEvalOrientation cMeshEval(kernel);
    std::vector<FacetIndex> inds = cMeshEval.GetIndices();
    Py::Tuple tuple(inds.size());
    for (std::size_t i=0; i<inds.size(); i++) {
        tuple.setItem(i, Py::Long(inds[i]));
    }

    return Py::new_reference_to(tuple);
}

PyObject*  MeshPy::harmonizeNormals(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        MeshPropertyLock lock(this->parentProperty);
        getMeshObjectPtr()->harmonizeNormals();
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::countComponents(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    unsigned long count = getMeshObjectPtr()->countComponents();
    return Py_BuildValue("k",count);
}

PyObject*  MeshPy::removeComponents(PyObject *args)
{
    unsigned long count;
    if (!PyArg_ParseTuple(args, "k", &count))
        return nullptr;

    PY_TRY {
        if (count > 0) {
            getMeshObjectPtr()->removeComponents(count);
        }
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::fillupHoles(PyObject *args)
{
    unsigned long len;
    int level = 0;
    float max_area = 0.0f;
    if (!PyArg_ParseTuple(args, "k|if", &len,&level,&max_area))
        return nullptr;
    try {
        std::unique_ptr<MeshCore::AbstractPolygonTriangulator> tria;
        if (max_area > 0.0f) {
            tria = std::unique_ptr<MeshCore::AbstractPolygonTriangulator>
                (new MeshCore::ConstraintDelaunayTriangulator(max_area));
        }
        else {
            tria = std::unique_ptr<MeshCore::AbstractPolygonTriangulator>
                (new MeshCore::FlatTriangulator());
        }

        MeshPropertyLock lock(this->parentProperty);
        tria->SetVerifier(new MeshCore::TriangulationVerifierV2);
        getMeshObjectPtr()->fillupHoles(len, level, *tria);
    }
    catch (const Base::Exception& e) {
        e.setPyException();
        return nullptr;
    }

    Py_Return;
}

PyObject*  MeshPy::fixIndices(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->validateIndices();
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::fixCaps(PyObject *args)
{
    float fMaxAngle = Base::toRadians<float>(150.0f);
    float fSplitFactor = 0.25f;
    if (!PyArg_ParseTuple(args, "|ff", &fMaxAngle, &fSplitFactor))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->validateCaps(fMaxAngle, fSplitFactor);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::fixDeformations(PyObject *args)
{
    float fMaxAngle;
    float fEpsilon = MeshCore::MeshDefinitions::_fMinPointDistanceP2;
    if (!PyArg_ParseTuple(args, "f|f", &fMaxAngle, &fEpsilon))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->validateDeformations(fMaxAngle, fEpsilon);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::fixDegenerations(PyObject *args)
{
    float fEpsilon = MeshCore::MeshDefinitions::_fMinPointDistanceP2;
    if (!PyArg_ParseTuple(args, "|f", &fEpsilon))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->validateDegenerations(fEpsilon);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::removeDuplicatedPoints(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->removeDuplicatedPoints();
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::removeDuplicatedFacets(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->removeDuplicatedFacets();
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::refine(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->refine();
    } PY_CATCH;

    Py_Return;
}

PyObject* MeshPy::removeNeedles(PyObject *args)
{
    float length;
    if (!PyArg_ParseTuple(args, "f", &length))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->removeNeedles(length);
    } PY_CATCH;

    Py_Return;
}

PyObject* MeshPy::removeFullBoundaryFacets(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->removeFullBoundaryFacets();
    } PY_CATCH;

    Py_Return;
}

PyObject* MeshPy::mergeFacets(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->mergeFacets();
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::optimizeTopology(PyObject *args)
{
    float fMaxAngle=-1.0f;
    if (!PyArg_ParseTuple(args, "|f; specify the maximum allowed angle between the normals of two adjacent facets", &fMaxAngle))
        return nullptr;

    PY_TRY {
        MeshPropertyLock lock(this->parentProperty);
        getMeshObjectPtr()->optimizeTopology(fMaxAngle);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::optimizeEdges(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        MeshPropertyLock lock(this->parentProperty);
        getMeshObjectPtr()->optimizeEdges();
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::splitEdges(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    PY_TRY {
        getMeshObjectPtr()->splitEdges();
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::splitEdge(PyObject *args)
{
    unsigned long facet, neighbour;
    PyObject* vertex;
    if (!PyArg_ParseTuple(args, "kkO!", &facet, &neighbour, &Base::VectorPy::Type, &vertex))
        return nullptr;

    Base::VectorPy  *pcObject = static_cast<Base::VectorPy*>(vertex);
    Base::Vector3d* val = pcObject->getVectorPtr();
    Base::Vector3f v((float)val->x,(float)val->y,(float)val->z);

    const MeshCore::MeshKernel& kernel = getMeshObjectPtr()->getKernel();
    PY_TRY {
        if (facet >= kernel.CountFacets()) {
            PyErr_SetString(PyExc_IndexError, "Facet index out of range");
            return nullptr;
        }
        if (neighbour >= kernel.CountFacets()) {
            PyErr_SetString(PyExc_IndexError, "Facet index out of range");
            return nullptr;
        }

        const MeshCore::MeshFacet& rclF = kernel.GetFacets()[facet];
        if (rclF._aulNeighbours[0] != neighbour && rclF._aulNeighbours[1] != neighbour &&
            rclF._aulNeighbours[2] != neighbour) {
            PyErr_SetString(PyExc_IndexError, "No adjacent facets");
            return nullptr;
        }

        getMeshObjectPtr()->splitEdge(facet, neighbour, v);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::splitFacet(PyObject *args)
{
    unsigned long facet;
    PyObject* vertex1;
    PyObject* vertex2;
    if (!PyArg_ParseTuple(args, "kO!O!", &facet, &Base::VectorPy::Type, &vertex1,
                                                 &Base::VectorPy::Type, &vertex2))
        return nullptr;

    Base::VectorPy  *pcObject = static_cast<Base::VectorPy*>(vertex1);
    Base::Vector3d* val = pcObject->getVectorPtr();
    Base::Vector3f v1((float)val->x,(float)val->y,(float)val->z);

    pcObject = static_cast<Base::VectorPy*>(vertex2);
    val = pcObject->getVectorPtr();
    Base::Vector3f v2((float)val->x,(float)val->y,(float)val->z);

    const MeshCore::MeshKernel& kernel = getMeshObjectPtr()->getKernel();
    PY_TRY {
        if (facet >= kernel.CountFacets()) {
            PyErr_SetString(PyExc_IndexError, "Facet index out of range");
            return nullptr;
        }

        getMeshObjectPtr()->splitFacet(facet, v1, v2);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::swapEdge(PyObject *args)
{
    unsigned long facet, neighbour;
    if (!PyArg_ParseTuple(args, "kk", &facet, &neighbour))
        return nullptr;

    const MeshCore::MeshKernel& kernel = getMeshObjectPtr()->getKernel();
    PY_TRY {
        if (facet >= kernel.CountFacets()) {
            PyErr_SetString(PyExc_IndexError, "Facet index out of range");
            return nullptr;
        }
        if (neighbour >= kernel.CountFacets()) {
            PyErr_SetString(PyExc_IndexError, "Facet index out of range");
            return nullptr;
        }

        const MeshCore::MeshFacet& rclF = kernel.GetFacets()[facet];
        if (rclF._aulNeighbours[0] != neighbour && rclF._aulNeighbours[1] != neighbour &&
            rclF._aulNeighbours[2] != neighbour) {
            PyErr_SetString(PyExc_IndexError, "No adjacent facets");
            return nullptr;
        }

        getMeshObjectPtr()->swapEdge(facet, neighbour);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::collapseEdge(PyObject *args)
{
    unsigned long facet, neighbour;
    if (!PyArg_ParseTuple(args, "kk", &facet, &neighbour))
        return nullptr;

    const MeshCore::MeshKernel& kernel = getMeshObjectPtr()->getKernel();
    PY_TRY {
        if (facet >= kernel.CountFacets()) {
            PyErr_SetString(PyExc_IndexError, "Facet index out of range");
            return nullptr;
        }
        if (neighbour >= kernel.CountFacets()) {
            PyErr_SetString(PyExc_IndexError, "Facet index out of range");
            return nullptr;
        }

        const MeshCore::MeshFacet& rclF = kernel.GetFacets()[facet];
        if (rclF._aulNeighbours[0] != neighbour && rclF._aulNeighbours[1] != neighbour &&
            rclF._aulNeighbours[2] != neighbour) {
            PyErr_SetString(PyExc_IndexError, "No adjacent facets");
            return nullptr;
        }

        getMeshObjectPtr()->collapseEdge(facet, neighbour);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::collapseFacet(PyObject *args)
{
    unsigned long facet;
    if (!PyArg_ParseTuple(args, "k", &facet))
        return nullptr;

    PY_TRY {
        if (facet >= getMeshObjectPtr()->countFacets()) {
            PyErr_SetString(PyExc_IndexError, "Facet index out of range");
            return nullptr;
        }

        getMeshObjectPtr()->collapseFacet(facet);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::insertVertex(PyObject *args)
{
    unsigned long facet;
    PyObject* vertex;
    if (!PyArg_ParseTuple(args, "kO!", &facet, &Base::VectorPy::Type, &vertex))
        return nullptr;

    Base::VectorPy  *pcObject = static_cast<Base::VectorPy*>(vertex);
    Base::Vector3d* val = pcObject->getVectorPtr();
    Base::Vector3f v((float)val->x,(float)val->y,(float)val->z);

    PY_TRY {
        if (facet >= getMeshObjectPtr()->countFacets()) {
            PyErr_SetString(PyExc_IndexError, "Facet index out of range");
            return nullptr;
        }

        getMeshObjectPtr()->insertVertex(facet, v);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::snapVertex(PyObject *args)
{
    unsigned long facet;
    PyObject* vertex;
    if (!PyArg_ParseTuple(args, "kO!", &facet, &Base::VectorPy::Type, &vertex))
        return nullptr;

    Base::VectorPy  *pcObject = static_cast<Base::VectorPy*>(vertex);
    Base::Vector3d* val = pcObject->getVectorPtr();
    Base::Vector3f v((float)val->x,(float)val->y,(float)val->z);

    PY_TRY {
        if (facet >= getMeshObjectPtr()->countFacets()) {
            PyErr_SetString(PyExc_IndexError, "Facet index out of range");
            return nullptr;
        }

        getMeshObjectPtr()->snapVertex(facet, v);
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::printInfo(PyObject *args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;
    return Py_BuildValue("s", getMeshObjectPtr()->topologyInfo().c_str());
}

PyObject*  MeshPy::collapseFacets(PyObject *args)
{
    PyObject *pcObj=nullptr;
    if (!PyArg_ParseTuple(args, "O", &pcObj))
        return nullptr;

    // if no mesh is given
    try {
        Py::Sequence list(pcObj);
        std::vector<FacetIndex> facets;
        for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
            Py::Long idx(*it);
            unsigned long iIdx = static_cast<unsigned long>(idx);
            facets.push_back(iIdx);
        }

        getMeshObjectPtr()->collapseFacets(facets);
    }
    catch (const Py::Exception&) {
        return nullptr;
    }

    Py_Return;
}

PyObject* MeshPy::foraminate(PyObject *args)
{
    PyObject* pnt_p;
    PyObject* dir_p;
    double maxAngle = MeshCore::Mathd::PI;
    if (!PyArg_ParseTuple(args, "OO|d", &pnt_p, &dir_p, &maxAngle))
        return nullptr;

    try {
        Py::Vector pnt_t(pnt_p, false);
        Py::Vector dir_t(dir_p, false);

        MeshObject::TRay ray = std::make_pair(pnt_t.toVector(),
                                              dir_t.toVector());
        auto output = getMeshObjectPtr()->foraminate(ray, maxAngle);

        Py::Dict dict;
        for (const auto& it : output) {
            Py::Tuple tuple(3);
            tuple.setItem(0, Py::Float(it.second.x));
            tuple.setItem(1, Py::Float(it.second.y));
            tuple.setItem(2, Py::Float(it.second.z));
            dict.setItem(Py::Long(it.first), tuple);
        }

        return Py::new_reference_to(dict);
    }
    catch (const Py::Exception&) {
        return nullptr;
    }
}

PyObject*  MeshPy::cut(PyObject *args)
{
    PyObject* poly;
    int mode;
    if (!PyArg_ParseTuple(args, "Oi", &poly, &mode))
        return nullptr;

    Py::Sequence list(poly);
    std::vector<Base::Vector3f> polygon;
    polygon.reserve(list.size());
    for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
        Base::Vector3d pnt = Py::Vector(*it).toVector();
        polygon.push_back(Base::convertTo<Base::Vector3f>(pnt));
    }

    MeshCore::FlatTriangulator tria;
    tria.SetPolygon(polygon);
    // this gives us the inverse matrix
    Base::Matrix4D inv = tria.GetTransformToFitPlane();
    // compute the matrix for the coordinate transformation
    Base::Matrix4D mat = inv;
    mat.inverseOrthogonal();

    polygon = tria.ProjectToFitPlane();

    Base::ViewProjMatrix proj(mat);
    Base::Polygon2d polygon2d;
    for (auto it : polygon)
        polygon2d.Add(Base::Vector2d(it.x, it.y));
    getMeshObjectPtr()->cut(polygon2d, proj, MeshObject::CutType(mode));

    Py_Return;
}

PyObject*  MeshPy::trim(PyObject *args)
{
    PyObject* poly;
    int mode;
    if (!PyArg_ParseTuple(args, "Oi", &poly, &mode))
        return nullptr;

    Py::Sequence list(poly);
    std::vector<Base::Vector3f> polygon;
    polygon.reserve(list.size());
    for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
        Base::Vector3d pnt = Py::Vector(*it).toVector();
        polygon.push_back(Base::convertTo<Base::Vector3f>(pnt));
    }

    MeshCore::FlatTriangulator tria;
    tria.SetPolygon(polygon);
    // this gives us the inverse matrix
    Base::Matrix4D inv = tria.GetTransformToFitPlane();
    // compute the matrix for the coordinate transformation
    Base::Matrix4D mat = inv;
    mat.inverseOrthogonal();

    polygon = tria.ProjectToFitPlane();

    Base::ViewOrthoProjMatrix proj(mat);
    Base::Polygon2d polygon2d;
    for (auto it : polygon)
        polygon2d.Add(Base::Vector2d(it.x, it.y));
    getMeshObjectPtr()->trim(polygon2d, proj, MeshObject::CutType(mode));

    Py_Return;
}

PyObject*  MeshPy::trimByPlane(PyObject *args)
{
    PyObject *base, *norm;
    if (!PyArg_ParseTuple(args, "O!O!", &Base::VectorPy::Type, &base,
                                        &Base::VectorPy::Type, &norm))
        return nullptr;

    Base::Vector3d pnt = Py::Vector(base, false).toVector();
    Base::Vector3d dir = Py::Vector(norm, false).toVector();

    getMeshObjectPtr()->trimByPlane(Base::convertTo<Base::Vector3f>(pnt),
                                    Base::convertTo<Base::Vector3f>(dir));

    Py_Return;
}

PyObject* MeshPy::smooth(PyObject *args, PyObject *kwds)
{
    char* method = "Laplace";
    int iter=1;
    double lambda = 0;
    double micro = 0;
    double maximum = 1000;
    int weight = 1;
    static const std::array<const char *, 7> keywords_smooth{"Method", "Iteration", "Lambda", "Micro", "Maximum",
                                                             "Weight", nullptr};
    if (!Base::Wrapped_ParseTupleAndKeywords(args, kwds, "|sidddi",keywords_smooth,
                                            &method, &iter, &lambda, &micro, &maximum, &weight)) {
        return nullptr;
    }

    PY_TRY {
        MeshPropertyLock lock(this->parentProperty);
        MeshCore::MeshKernel& kernel = getMeshObjectPtr()->getKernel();
        if (strcmp(method, "Laplace") == 0) {
            MeshCore::LaplaceSmoothing smooth(kernel);
            if (lambda > 0)
                smooth.SetLambda(lambda);
            smooth.Smooth(iter);
        }
        else if (strcmp(method, "Taubin") == 0) {
            MeshCore::TaubinSmoothing smooth(kernel);
            if (lambda > 0)
                smooth.SetLambda(lambda);
            if (micro > 0)
                smooth.SetMicro(micro);
            smooth.Smooth(iter);
        }
        else if (strcmp(method, "PlaneFit") == 0) {
            MeshCore::PlaneFitSmoothing smooth(kernel);
            smooth.SetMaximum(maximum);
            smooth.Smooth(iter);
        }
        else if (strcmp(method, "MedianFilter") == 0) {
            MeshCore::MedianFilterSmoothing smooth(kernel);
            smooth.SetWeight(weight);
            smooth.Smooth(iter);
        }
        else {
            throw Py::ValueError("No such smoothing algorithm");
        }
    } PY_CATCH;

    Py_Return;
}

PyObject*  MeshPy::decimate(PyObject *args)
{
    float fTol, fRed;
    if (PyArg_ParseTuple(args, "ff", &fTol,&fRed)) {
        PY_TRY {
            getMeshObjectPtr()->decimate(fTol, fRed);
        } PY_CATCH;

        Py_Return;
    }

    PyErr_Clear();
    int targetSize;
    if (PyArg_ParseTuple(args, "i", &targetSize)) {
        PY_TRY {
            getMeshObjectPtr()->decimate(targetSize);
        } PY_CATCH;

        Py_Return;
    }

    PyErr_SetString(PyExc_ValueError, "decimate(tolerance=float, reduction=float) or decimate(targetSize=int)");
    return nullptr;
}

PyObject* MeshPy::nearestFacetOnRay(PyObject *args)
{
    PyObject* pnt_p;
    PyObject* dir_p;
    double maxAngle = MeshCore::Mathd::PI;
    if (!PyArg_ParseTuple(args, "OO|d", &pnt_p, &dir_p, &maxAngle))
        return nullptr;

    try {
        Py::Vector pnt_t(pnt_p, false);
        Py::Vector dir_t(dir_p, false);
        Py::Dict dict;

        MeshObject::TRay ray = std::make_pair(pnt_t.toVector(),
                                              dir_t.toVector());
        MeshObject::TFaceSection output;
        if (getMeshObjectPtr()->nearestFacetOnRay(ray, maxAngle, output)) {
            Py::Tuple tuple(3);
            tuple.setItem(0, Py::Float(output.second.x));
            tuple.setItem(1, Py::Float(output.second.y));
            tuple.setItem(2, Py::Float(output.second.z));
            dict.setItem(Py::Long(static_cast<int>(output.first)), tuple);
        }

        return Py::new_reference_to(dict);
    }
    catch (const Py::Exception&) {
        return nullptr;
    }
}

PyObject*  MeshPy::getPlanarSegments(PyObject *args)
{
    float dev;
    unsigned long minFacets=0;
    if (!PyArg_ParseTuple(args, "f|k",&dev,&minFacets))
        return nullptr;

    Mesh::MeshObject* mesh = getMeshObjectPtr();
    std::vector<Mesh::Segment> segments = mesh->getSegmentsOfType
        (Mesh::MeshObject::PLANE, dev, minFacets);

    Py::List s;
    for (const auto & segment : segments) {
        const std::vector<FacetIndex>& segm = segment.getIndices();
        Py::List ary;
        for (FacetIndex jt : segm) {
            ary.append(Py::Long(jt));
        }
        s.append(ary);
    }

    return Py::new_reference_to(s);
}

PyObject*  MeshPy::getSegmentsOfType(PyObject *args)
{
    char* type;
    float dev;
    unsigned long minFacets=0;
    if (!PyArg_ParseTuple(args, "sf|k",&type,&dev,&minFacets))
        return nullptr;

    Mesh::MeshObject::GeometryType geoType;
    if (strcmp(type, "Plane") == 0) {
        geoType = Mesh::MeshObject::PLANE;
    }
    else if (strcmp(type, "Cylinder") == 0) {
        geoType = Mesh::MeshObject::CYLINDER;
    }
    else if (strcmp(type, "Sphere") == 0) {
        geoType = Mesh::MeshObject::SPHERE;
    }
    else {
        PyErr_SetString(PyExc_ValueError, "Unsupported surface type");
        return nullptr;
    }

    Mesh::MeshObject* mesh = getMeshObjectPtr();
    std::vector<Mesh::Segment> segments = mesh->getSegmentsOfType
        (geoType, dev, minFacets);

    Py::List s;
    for (const auto & segment : segments) {
        const std::vector<FacetIndex>& segm = segment.getIndices();
        Py::List ary;
        for (FacetIndex jt : segm) {
            ary.append(Py::Long(int(jt)));
        }
        s.append(ary);
    }

    return Py::new_reference_to(s);
}

PyObject*  MeshPy::getSegmentsByCurvature(PyObject *args)
{
    PyObject* l;
    if (!PyArg_ParseTuple(args, "O",&l))
        return nullptr;

    const MeshCore::MeshKernel& kernel = getMeshObjectPtr()->getKernel();
    MeshCore::MeshSegmentAlgorithm finder(kernel);
    MeshCore::MeshCurvature meshCurv(kernel);
    meshCurv.ComputePerVertex();

    Py::Sequence func(l);
    std::vector<MeshCore::MeshSurfaceSegmentPtr> segm;
    for (Py::Sequence::iterator it = func.begin(); it != func.end(); ++it) {
        Py::Tuple t(*it);
        float c1 = (float)Py::Float(t[0]);
        float c2 = (float)Py::Float(t[1]);
        float tol1 = (float)Py::Float(t[2]);
        float tol2 = (float)Py::Float(t[3]);
        int num = (int)Py::Long(t[4]);
        segm.emplace_back(std::make_shared<MeshCore::MeshCurvatureFreeformSegment>(meshCurv.GetCurvature(), num, tol1, tol2, c1, c2));
    }

    finder.FindSegments(segm);

    Py::List list;
    for (const auto & segmIt : segm) {
        const std::vector<MeshCore::MeshSegment>& data = segmIt->GetSegments();
        for (const auto & it : data) {
            Py::List ary;
            for (FacetIndex jt : it) {
                ary.append(Py::Long(int(jt)));
            }
            list.append(ary);
        }
    }

    return Py::new_reference_to(list);
}

PyObject* MeshPy::getCurvaturePerVertex(PyObject* args)
{
    if (!PyArg_ParseTuple(args, ""))
        return nullptr;

    const MeshCore::MeshKernel& kernel = getMeshObjectPtr()->getKernel();
    MeshCore::MeshCurvature meshCurv(kernel);
    meshCurv.ComputePerVertex();

    const std::vector<MeshCore::CurvatureInfo>& curv = meshCurv.GetCurvature();
    Base::Placement plm = getMeshObjectPtr()->getPlacement();
    plm.setPosition(Base::Vector3d());

    Py::List list;
    for (const auto& it : curv) {
        Base::Vector3d maxCurve = Base::convertTo<Base::Vector3d>(it.cMaxCurvDir);
        Base::Vector3d minCurve = Base::convertTo<Base::Vector3d>(it.cMinCurvDir);
        plm.multVec(maxCurve, maxCurve);
        plm.multVec(minCurve, minCurve);

        Py::Tuple tuple(4);
        tuple.setItem(0, Py::Float(it.fMaxCurvature));
        tuple.setItem(1, Py::Float(it.fMinCurvature));
        tuple.setItem(2, Py::Vector(maxCurve));
        tuple.setItem(3, Py::Vector(minCurve));
        list.append(tuple);
    }

    return Py::new_reference_to(list);
}

Py::Long MeshPy::getCountPoints() const
{
    return Py::Long((long)getMeshObjectPtr()->countPoints());
}

Py::Long MeshPy::getCountEdges() const
{
    return Py::Long((long)getMeshObjectPtr()->countEdges());
}

Py::Long MeshPy::getCountFacets() const
{
    return Py::Long((long)getMeshObjectPtr()->countFacets());
}

Py::Float MeshPy::getArea() const
{
    return Py::Float(getMeshObjectPtr()->getSurface());
}

Py::Float MeshPy::getVolume() const
{
    return Py::Float(getMeshObjectPtr()->getVolume());
}

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

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

Py::List MeshPy::getPoints() const
{
    Py::List PointList;
    unsigned int Index=0;
    MeshObject* mesh = getMeshObjectPtr();
    for (MeshObject::const_point_iterator it = mesh->points_begin(); it != mesh->points_end(); ++it) {
        PointList.append(Py::Object(new MeshPointPy(new MeshPoint(*it,getMeshObjectPtr(),Index++)), true));
    }
    return PointList;
}

Py::List MeshPy::getFacets() const
{
    Py::List FacetList;
    MeshObject* mesh = getMeshObjectPtr();
    for (MeshObject::const_facet_iterator it = mesh->facets_begin(); it != mesh->facets_end(); ++it) {
        FacetList.append(Py::Object(new FacetPy(new Facet(*it)), true));
    }
    return FacetList;
}

Py::Tuple MeshPy::getTopology() const
{
    std::vector<Base::Vector3d> Points;
    std::vector<Data::ComplexGeoData::Facet> Facets;
    getMeshObjectPtr()->getFaces(Points, Facets, 0.0);
    Py::Tuple tuple(2);
    Py::List vertex;
    for (const auto & Point : Points)
        vertex.append(Py::asObject(new Base::VectorPy(Point)));
    tuple.setItem(0, vertex);
    Py::List facet;
    for (auto it : Facets) {
        Py::Tuple f(3);
        f.setItem(0,Py::Long((int)it.I1));
        f.setItem(1,Py::Long((int)it.I2));
        f.setItem(2,Py::Long((int)it.I3));
        facet.append(f);
    }
    tuple.setItem(1, facet);
    return tuple;
}