kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

implement optional Python binding for flatmesh using boost

Browse Source
This commit is contained in:
wmayer
2018-04-28 22:27:09 +02:00
parent 1dfb7c5088
commit cf655e2365
8 changed files with 256 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/Mod/MeshPart/App/CMakeLists.txt
View File

@@ -92,5 +92,41 @@ if (FREECAD_USE_PYBIND11)
SET_BIN_DIR(flatmesh flatmesh /Mod/MeshPart)
install(TARGETS flatmesh DESTINATION ${CMAKE_INSTALL_LIBDIR})
else()
if(NOT FREECAD_LIBPACK_USE OR FREECAD_LIBPACK_CHECKFILE_CLBUNDLER)
# boost-python >= 1.67 on some platforms has suffix
set(BOOST_PY_SUFFIX ${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR})
find_package( Boost COMPONENTS python${BOOST_PY_SUFFIX} )
if (NOT Boost_PYTHON${BOOST_PY_SUFFIX}_FOUND)
# try just the major version
find_package( Boost COMPONENTS python${PYTHON_VERSION_MAJOR} )
if (NOT Boost_PYTHON${PYTHON_VERSION_MAJOR}_FOUND)
# unversioned
find_package( Boost COMPONENTS python REQUIRED)
endif()
endif()
if(Boost_FOUND)
include_directories(${Boost_INCLUDE_DIRS})
SET(FLATMESH_SRCS
MeshFlattening.cpp
MeshFlattening.h
MeshFlatteningNurbs.h
MeshFlatteningNurbs.cpp
MeshFlatteningLscmRelax.h
MeshFlatteningLscmRelax.cpp
MeshFlatteningBoostPython.cpp
)
add_library(flatmesh SHARED ${FLATMESH_SRCS})
SET_PYTHON_PREFIX_SUFFIX(flatmesh)
target_link_libraries(flatmesh ${PYTHON_LIBRARIES} ${MeshPart_LIBS} ${Boost_LIBRARIES})
SET_BIN_DIR(flatmesh flatmesh /Mod/MeshPart)
install(TARGETS flatmesh DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif()
endif()
endif()
############################################################################

1
src/Mod/MeshPart/App/MeshFlattening.cpp
View File

@@ -21,6 +21,7 @@
***************************************************************************/
#include "PreCompiled.h"
#include "MeshFlattening.h"
#include "MeshFlatteningLscmRelax.h"
#include <Poly_Triangulation.hxx>

1
src/Mod/MeshPart/App/MeshFlattening.h
View File

@@ -61,6 +61,7 @@ std::vector<ColMat<double, 3>> getBoundaries(ColMat<double, 3> vertices, ColMat<
class FaceUnwrapper{
nurbs::NurbsBase2D nu;
public:
FaceUnwrapper(){}
FaceUnwrapper(const TopoDS_Face & face);
FaceUnwrapper(ColMat<double, 3> xyz_nodes, ColMat<long, 3> tris);
void findFlatNodes(int steps, double val);

213
src/Mod/MeshPart/App/MeshFlatteningBoostPython.cpp Normal file
View File

@@ -0,0 +1,213 @@
/***************************************************************************
* Copyright (c) 2017 Lorenz Lechner *
* *
* 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/Interpreter.h>
#include <Mod/Part/App/TopoShapeFacePy.h>
#include <Mod/Part/App/TopoShapeEdgePy.h>
#include <Eigen/Core>
#include <Eigen/Geometry>
#include <Eigen/Sparse>
#include <boost/python.hpp>
#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/wrapper.hpp>
#include <boost/python/call.hpp>
#include <boost/python/copy_const_reference.hpp>
#include <boost/python/return_value_policy.hpp>
#include <memory>
#include <vector>
#include <tuple>
#include <map>
#include <stdexcept>
#include "MeshFlattening.h"
#include "MeshFlatteningLscmRelax.h"
#include "MeshFlatteningNurbs.h"
#include <TopoDS_Face.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS.hxx>
#include <ShapeFix_Edge.hxx>
namespace py = boost::python;
const TopoDS_Face& getTopoDSFace(const py::object& face)
{
if (PyObject_TypeCheck(face.ptr(), &(Part::TopoShapeFacePy::Type)))
{
const Part::TopoShapeFacePy* f = static_cast<Part::TopoShapeFacePy*>(face.ptr());
const TopoDS_Face& myFace = TopoDS::Face(f->getTopoShapePtr()->getShape());
return myFace;
}
else
throw std::invalid_argument("must be a face");
}
const TopoDS_Edge& getTopoDSEdge(py::object* edge)
{
if (PyObject_TypeCheck(edge->ptr(), &(Part::TopoShapeEdgePy::Type)))
{
const Part::TopoShapeEdgePy* e = static_cast<Part::TopoShapeEdgePy*>(edge->ptr());
const TopoDS_Edge& myEdge = TopoDS::Edge(e->getTopoShapePtr()->getShape());
return myEdge;
}
else
throw std::invalid_argument("must be an edge");
}
Py::Object makeEdge(const TopoDS_Edge& edge)
{
return Py::asObject(new Part::TopoShapeEdgePy(new Part::TopoShape(edge)));
}
boost::shared_ptr<FaceUnwrapper> FaceUnwrapper_face(const py::object& face)
{
const TopoDS_Face& myFace = getTopoDSFace(face);
return boost::shared_ptr<FaceUnwrapper>(new FaceUnwrapper(myFace));
}
boost::shared_ptr<FaceUnwrapper> FaceUnwrapper_mesh(const py::object& points,
const py::object& facets)
{
try {
Py::Sequence l1(points.ptr());
ColMat<double, 3> coords;
coords.resize(l1.size(), 3);
int row = 0;
for (Py::Sequence::iterator it = l1.begin(); it != l1.end(); ++it) {
Py::Sequence c(*it);
int col = 0;
for (Py::Sequence::iterator jt = c.begin(); jt != c.end(); ++jt, ++col) {
double v = static_cast<double>(Py::Float(*jt));
coords(row, col) = v;
}
}
Py::Sequence l2(facets.ptr());
ColMat<long, 3> triangles;
triangles.resize(l2.size(), 3);
for (Py::Sequence::iterator it = l2.begin(); it != l2.end(); ++it) {
Py::Sequence c(*it);
int col = 0;
for (Py::Sequence::iterator jt = c.begin(); jt != c.end(); ++jt, ++col) {
long v = static_cast<long>(Py::Long(*jt));
triangles(row, col) = v;
}
}
return boost::shared_ptr<FaceUnwrapper>(new FaceUnwrapper(coords, triangles));
}
catch (const Py::Exception&) {
Base::PyException e;
throw std::invalid_argument(e.what());
}
}
boost::python::list interpolateFlatFacePy(FaceUnwrapper& instance, const py::object& face)
{
const TopoDS_Face& myFace = getTopoDSFace(face);
ColMat<double, 3> mat = instance.interpolateFlatFace(myFace);
boost::python::list plist;
auto cols = mat.cols();
auto rows = mat.rows();
for (int i=0; i<rows; i++) {
boost::python::list vec;
for (int j=0; j<cols; j++) {
double c = mat.coeff(i, j);
vec.append(c);
}
plist.append(vec);
}
return plist;
}
BOOST_PYTHON_MODULE(flatmesh)
{
//m.doc() = "functions to unwrapp faces/ meshes";
py::class_<lscmrelax::LscmRelax>("LscmRelax")
.def(py::init<ColMat<double, 3>, ColMat<long, 3>, std::vector<long>>())
.def("lscm", &lscmrelax::LscmRelax::lscm)
.def("relax", &lscmrelax::LscmRelax::relax)
.def("rotate_by_min_bound_area", &lscmrelax::LscmRelax::rotate_by_min_bound_area)
.def("transform", &lscmrelax::LscmRelax::transform)
.def_readonly("rhs", &lscmrelax::LscmRelax::rhs)
.def_readonly("MATRIX", &lscmrelax::LscmRelax::MATRIX)
.def_readonly("area", &lscmrelax::LscmRelax::get_area)
.def_readonly("flat_area", &lscmrelax::LscmRelax::get_flat_area)
// .def_readonly("flat_vertices", [](lscmrelax::LscmRelax& L){return L.flat_vertices.transpose();}, py::return_value_policy<py::copy_const_reference>())
.def_readonly("flat_vertices_3D", &lscmrelax::LscmRelax::get_flat_vertices_3D);
py::class_<nurbs::NurbsBase2D>("NurbsBase2D")
.def(py::init<Eigen::VectorXd, Eigen::VectorXd, Eigen::VectorXd, int, int>())
.def_readonly("u_knots", &nurbs::NurbsBase2D::u_knots)
.def_readonly("weights", &nurbs::NurbsBase2D::weights)
.def_readonly("degree_u", &nurbs::NurbsBase2D::degree_u)
// .def_readonly("v_knots", &nurbs::NurbsBase2D::u_knots)
.def_readonly("degree_v", &nurbs::NurbsBase2D::degree_u)
.def("getUVMesh", &nurbs::NurbsBase2D::getUVMesh)
.def("computeFirstDerivatives", &nurbs::NurbsBase2D::computeFirstDerivatives)
.def("getInfluenceVector", &nurbs::NurbsBase2D::getInfluenceVector)
.def("getInfluenceMatrix", &nurbs::NurbsBase2D::getInfluenceMatrix)
.def("getDuVector", &nurbs::NurbsBase2D::getDuVector)
.def("getDuMatrix", &nurbs::NurbsBase2D::getDuMatrix)
.def("getDvVector", &nurbs::NurbsBase2D::getDvVector)
.def("getDvMatrix", &nurbs::NurbsBase2D::getDvMatrix)
.def("interpolateUBS", &nurbs::NurbsBase2D::interpolateUBS);
py::class_<nurbs::NurbsBase1D>("NurbsBase1D")
.def(py::init<Eigen::VectorXd, Eigen::VectorXd, int>())
.def_readonly("u_knots", &nurbs::NurbsBase1D::u_knots)
.def_readonly("weights", &nurbs::NurbsBase1D::weights)
.def_readonly("degree_u", &nurbs::NurbsBase1D::degree_u)
.def("getUMesh", &nurbs::NurbsBase1D::getUMesh)
.def("computeFirstDerivatives", &nurbs::NurbsBase1D::computeFirstDerivatives)
.def("getInfluenceVector", &nurbs::NurbsBase1D::getInfluenceVector)
.def("getInfluenceMatrix", &nurbs::NurbsBase1D::getInfluenceMatrix)
.def("getDuVector", &nurbs::NurbsBase1D::getDuVector)
.def("getDuMatrix", &nurbs::NurbsBase1D::getDuMatrix)
.add_static_property("getKnotSequence", &nurbs::NurbsBase1D::getKnotSequence)
.add_static_property("getWeightList", &nurbs::NurbsBase1D::getWeightList);
py::class_<FaceUnwrapper>("FaceUnwrapper")
.def("__init__", py::make_constructor(&FaceUnwrapper_face))
.def("__init__", py::make_constructor(&FaceUnwrapper_mesh))
.def(py::init<ColMat<double, 3>, ColMat<long, 3>>())
.def("findFlatNodes", &FaceUnwrapper::findFlatNodes)
.def("interpolateFlatFace", &interpolateFlatFacePy)
.def("getFlatBoundaryNodes", &FaceUnwrapper::getFlatBoundaryNodes)
.def_readonly("tris", &FaceUnwrapper::tris)
.def_readonly("nodes", &FaceUnwrapper::xyz_nodes)
.def_readonly("uv_nodes", &FaceUnwrapper::uv_nodes)
.def_readonly("ze_nodes", &FaceUnwrapper::ze_nodes)
.def_readonly("ze_poles", &FaceUnwrapper::ze_poles)
.def_readonly("A", &FaceUnwrapper::A);
}

1
src/Mod/MeshPart/App/MeshFlatteningLscmRelax.cpp
View File

@@ -21,6 +21,7 @@
***************************************************************************/
#include "PreCompiled.h"
#include "MeshFlatteningLscmRelax.h"
#include <Eigen/IterativeLinearSolvers>
#include <Eigen/SparseCholesky>

1
src/Mod/MeshPart/App/MeshFlatteningLscmRelax.h
View File

@@ -91,6 +91,7 @@ private:
Eigen::MatrixXd get_nullspace();
public:
LscmRelax() {}
LscmRelax(
RowMat<double, 3> vertices,
RowMat<long, 3> triangles,

1
src/Mod/MeshPart/App/MeshFlatteningNurbs.cpp
View File

@@ -21,6 +21,7 @@
***************************************************************************/
#include "PreCompiled.h"
#include "MeshFlatteningNurbs.h"
#include <iostream>
#include "math.h"

2
src/Mod/MeshPart/App/PreCompiled.h
View File

@@ -38,8 +38,10 @@
#endif
#ifdef _MSC_VER
# pragma warning(disable : 4244)
# pragma warning(disable : 4275)
# pragma warning(disable : 4290)
# pragma warning(disable : 4522)
#endif
#ifdef _PreComp_