suzanne.soy/FreeCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

+ add several surface reconstruction methods from pcl to Reen module

Browse Source
This commit is contained in:
wmayer 2015-12-05 16:19:18 +01:00
parent fd191b802e
commit 93b53f1662
3 changed files with 871 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

270
src/Mod/ReverseEngineering/App/AppReverseEngineering.cpp
View File

@ -59,12 +59,24 @@ public:
"Iterations=5,Correction=True,PatchFactor=1.0"
);
#if defined(HAVE_PCL_SURFACE)
add_varargs_method("triangulate",&Module::triangulate,
add_keyword_method("triangulate",&Module::triangulate,
"triangulate(PointKernel,searchRadius[,mu=2.5])."
);
add_keyword_method("poissonReconstruction",&Module::poissonReconstruction,
"poissonReconstruction(PointKernel)."
);
add_keyword_method("viewTriangulation",&Module::viewTriangulation,
"viewTriangulation(PointKernel, width, height)."
);
add_keyword_method("gridProjection",&Module::gridProjection,
"gridProjection(PointKernel)."
);
add_keyword_method("marchingCubesRBF",&Module::marchingCubesRBF,
"marchingCubesRBF(PointKernel)."
);
add_keyword_method("marchingCubesHoppe",&Module::marchingCubesHoppe,
"marchingCubesHoppe(PointKernel)."
);
#endif
#if defined(HAVE_PCL_OPENNURBS)
add_keyword_method("fitBSpline",&Module::fitBSpline,
@ -199,47 +211,270 @@ private:
}
}
#if defined(HAVE_PCL_SURFACE)
Py::Object triangulate(const Py::Tuple& args)
/*
import ReverseEngineering as Reen
import Points
import Mesh
import random
r=random.Random()
p=Points.Points()
pts=[]
for i in range(21):
for j in range(21):
pts.append(App.Vector(i,j,r.gauss(5,0.05)))
p.addPoints(pts)
m=Reen.triangulate(Points=p,SearchRadius=2.2)
Mesh.show(m)
*/
Py::Object triangulate(const Py::Tuple& args, const Py::Dict& kwds)
{
PyObject *pcObj;
PyObject *pts;
double searchRadius;
PyObject *vec = 0;
int ksearch=5;
double mu=2.5;
if (!PyArg_ParseTuple(args.ptr(), "O!d|d", &(Points::PointsPy::Type), &pcObj, &searchRadius, &mu))
static char* kwds_greedy[] = {"Points", "SearchRadius", "Mu", "KSearch",
"Normals", NULL};
if (!PyArg_ParseTupleAndKeywords(args.ptr(), kwds.ptr(), "O!d|diO", kwds_greedy,
&(Points::PointsPy::Type), &pts,
&searchRadius, &mu, &ksearch, &vec))
throw Py::Exception();
Points::PointsPy* pPoints = static_cast<Points::PointsPy*>(pcObj);
Points::PointKernel* points = pPoints->getPointKernelPtr();
Points::PointKernel* points = static_cast<Points::PointsPy*>(pts)->getPointKernelPtr();
Mesh::MeshObject* mesh = new Mesh::MeshObject();
SurfaceTriangulation tria(*points, *mesh);
tria.perform(searchRadius, mu);
tria.setMu(mu);
tria.setSearchRadius(searchRadius);
if (vec) {
Py::Sequence list(vec);
std::vector<Base::Vector3f> normals;
normals.reserve(list.size());
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
Base::Vector3d v = Py::Vector(*it).toVector();
normals.push_back(Base::convertTo<Base::Vector3f>(v));
}
tria.perform(normals);
}
else {
tria.perform(ksearch);
}
return Py::asObject(new Mesh::MeshPy(mesh));
}
Py::Object poissonReconstruction(const Py::Tuple& args, const Py::Dict& kwds)
{
PyObject *pcObj;
PyObject *pts;
PyObject *vec = 0;
int ksearch=5;
int octreeDepth=-1;
int solverDivide=-1;
double samplesPerNode=-1.0;
static char* kwds_poisson[] = {"Points", "KSearch", "OctreeDepth", "SolverDivide",
"SamplesPerNode", NULL};
if (!PyArg_ParseTupleAndKeywords(args.ptr(), kwds.ptr(), "O!|iiid", kwds_poisson,
&(Points::PointsPy::Type), &pcObj,
&ksearch, &octreeDepth, &solverDivide, &samplesPerNode))
"SamplesPerNode", "Normals", NULL};
if (!PyArg_ParseTupleAndKeywords(args.ptr(), kwds.ptr(), "O!|iiidO", kwds_poisson,
&(Points::PointsPy::Type), &pts,
&ksearch, &octreeDepth, &solverDivide, &samplesPerNode, &vec))
throw Py::Exception();
Points::PointsPy* pPoints = static_cast<Points::PointsPy*>(pcObj);
Points::PointKernel* points = pPoints->getPointKernelPtr();
Points::PointKernel* points = static_cast<Points::PointsPy*>(pts)->getPointKernelPtr();
Mesh::MeshObject* mesh = new Mesh::MeshObject();
Reen::PoissonReconstruction poisson(*points, *mesh);
poisson.setDepth(octreeDepth);
poisson.setSolverDivide(solverDivide);
poisson.setSamplesPerNode(samplesPerNode);
if (vec) {
Py::Sequence list(vec);
std::vector<Base::Vector3f> normals;
normals.reserve(list.size());
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
Base::Vector3d v = Py::Vector(*it).toVector();
normals.push_back(Base::convertTo<Base::Vector3f>(v));
}
poisson.perform(normals);
}
else {
poisson.perform(ksearch);
}
return Py::asObject(new Mesh::MeshPy(mesh));
}
/*
import ReverseEngineering as Reen
import Points
import Mesh
import random
import math
r=random.Random()
p=Points.Points()
pts=[]
for i in range(21):
for j in range(21):
pts.append(App.Vector(i,j,r.random()))
p.addPoints(pts)
m=Reen.viewTriangulation(p,21,21)
Mesh.show(m)
def boxmueller():
r1,r2=random.random(),random.random()
return math.sqrt(-2*math.log(r1))*math.cos(2*math.pi*r2)
p=Points.Points()
pts=[]
for i in range(21):
for j in range(21):
pts.append(App.Vector(i,j,r.gauss(5,0.05)))
p.addPoints(pts)
m=Reen.viewTriangulation(p,21,21)
Mesh.show(m)
*/
Py::Object viewTriangulation(const Py::Tuple& args, const Py::Dict& kwds)
{
PyObject *pts;
PyObject *vec = 0;
int width;
int height;
static char* kwds_greedy[] = {"Points", "Width", "Height", NULL};
if (!PyArg_ParseTupleAndKeywords(args.ptr(), kwds.ptr(), "O!|ii", kwds_greedy,
&(Points::PointsPy::Type), &pts,
&width, &height))
throw Py::Exception();
Points::PointKernel* points = static_cast<Points::PointsPy*>(pts)->getPointKernelPtr();
try {
Mesh::MeshObject* mesh = new Mesh::MeshObject();
ImageTriangulation view(width, height, *points, *mesh);
view.perform();
return Py::asObject(new Mesh::MeshPy(mesh));
}
catch (const Base::Exception& e) {
throw Py::RuntimeError(e.what());
}
}
Py::Object gridProjection(const Py::Tuple& args, const Py::Dict& kwds)
{
PyObject *pts;
PyObject *vec = 0;
int ksearch=5;
static char* kwds_greedy[] = {"Points", "KSearch", "Normals", NULL};
if (!PyArg_ParseTupleAndKeywords(args.ptr(), kwds.ptr(), "O!|iO", kwds_greedy,
&(Points::PointsPy::Type), &pts,
&ksearch, &vec))
throw Py::Exception();
Points::PointKernel* points = static_cast<Points::PointsPy*>(pts)->getPointKernelPtr();
Mesh::MeshObject* mesh = new Mesh::MeshObject();
GridReconstruction tria(*points, *mesh);
if (vec) {
Py::Sequence list(vec);
std::vector<Base::Vector3f> normals;
normals.reserve(list.size());
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
Base::Vector3d v = Py::Vector(*it).toVector();
normals.push_back(Base::convertTo<Base::Vector3f>(v));
}
tria.perform(normals);
}
else {
tria.perform(ksearch);
}
return Py::asObject(new Mesh::MeshPy(mesh));
}
Py::Object marchingCubesRBF(const Py::Tuple& args, const Py::Dict& kwds)
{
PyObject *pts;
PyObject *vec = 0;
int ksearch=5;
static char* kwds_greedy[] = {"Points", "KSearch", "Normals", NULL};
if (!PyArg_ParseTupleAndKeywords(args.ptr(), kwds.ptr(), "O!|iO", kwds_greedy,
&(Points::PointsPy::Type), &pts,
&ksearch, &vec))
throw Py::Exception();
Points::PointKernel* points = static_cast<Points::PointsPy*>(pts)->getPointKernelPtr();
Mesh::MeshObject* mesh = new Mesh::MeshObject();
MarchingCubesRBF tria(*points, *mesh);
if (vec) {
Py::Sequence list(vec);
std::vector<Base::Vector3f> normals;
normals.reserve(list.size());
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
Base::Vector3d v = Py::Vector(*it).toVector();
normals.push_back(Base::convertTo<Base::Vector3f>(v));
}
tria.perform(normals);
}
else {
tria.perform(ksearch);
}
return Py::asObject(new Mesh::MeshPy(mesh));
}
/*
import ReverseEngineering as Reen
import Points
import Mesh
import random
r=random.Random()
p=Points.Points()
pts=[]
for i in range(21):
for j in range(21):
pts.append(App.Vector(i,j,r.gauss(5,0.05)))
p.addPoints(pts)
m=Reen.marchingCubesHoppe(Points=p)
Mesh.show(m)
*/
Py::Object marchingCubesHoppe(const Py::Tuple& args, const Py::Dict& kwds)
{
PyObject *pts;
PyObject *vec = 0;
int ksearch=5;
static char* kwds_greedy[] = {"Points", "KSearch", "Normals", NULL};
if (!PyArg_ParseTupleAndKeywords(args.ptr(), kwds.ptr(), "O!|iO", kwds_greedy,
&(Points::PointsPy::Type), &pts,
&ksearch, &vec))
throw Py::Exception();
Points::PointKernel* points = static_cast<Points::PointsPy*>(pts)->getPointKernelPtr();
Mesh::MeshObject* mesh = new Mesh::MeshObject();
MarchingCubesHoppe tria(*points, *mesh);
if (vec) {
Py::Sequence list(vec);
std::vector<Base::Vector3f> normals;
normals.reserve(list.size());
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
Base::Vector3d v = Py::Vector(*it).toVector();
normals.push_back(Base::convertTo<Base::Vector3f>(v));
}
tria.perform(normals);
}
else {
tria.perform(ksearch);
}
return Py::asObject(new Mesh::MeshPy(mesh));
}
@ -247,7 +482,7 @@ private:
#if defined(HAVE_PCL_OPENNURBS)
Py::Object fitBSpline(const Py::Tuple& args, const Py::Dict& kwds)
{
PyObject *pcObj;
PyObject *pts;
int degree = 2;
int refinement = 4;
int iterations = 10;
@ -259,14 +494,13 @@ private:
static char* kwds_approx[] = {"Points", "Degree", "Refinement", "Iterations",
"InteriorSmoothness", "InteriorWeight", "BoundarySmoothness", "BoundaryWeight", NULL};
if (!PyArg_ParseTupleAndKeywords(args.ptr(), kwds.ptr(), "O!|iiidddd", kwds_approx,
&(Points::PointsPy::Type), &pcObj,
&(Points::PointsPy::Type), &pts,
&degree, &refinement, &iterations,
&interiorSmoothness, &interiorWeight,
&boundarySmoothness, &boundaryWeight))
throw Py::Exception();
Points::PointsPy* pPoints = static_cast<Points::PointsPy*>(pcObj);
Points::PointKernel* points = pPoints->getPointKernelPtr();
Points::PointKernel* points = static_cast<Points::PointsPy*>(pts)->getPointKernelPtr();
BSplineFitting fit(points->getBasicPoints());
fit.setOrder(degree+1);

516
src/Mod/ReverseEngineering/App/SurfaceTriangulation.cpp
View File

@ -26,8 +26,10 @@
#include "SurfaceTriangulation.h"
#include <Mod/Points/App/Points.h>
#include <Mod/Mesh/App/Mesh.h>
#include <Mod/Mesh/App/Core/Algorithm.h>
#include <Mod/Mesh/App/Core/Elements.h>
#include <Mod/Mesh/App/Core/MeshKernel.h>
#include <Base/Exception.h>
// http://svn.pointclouds.org/pcl/tags/pcl-1.5.1/test/
#if defined(HAVE_PCL_SURFACE)
@ -42,6 +44,8 @@
//#include <pcl/surface/convex_hull.h>
//#include <pcl/surface/concave_hull.h>
#include <pcl/surface/organized_fast_mesh.h>
#include <pcl/surface/marching_cubes_rbf.h>
#include <pcl/surface/marching_cubes_hoppe.h>
#include <pcl/surface/ear_clipping.h>
#include <pcl/common/common.h>
#include <boost/random.hpp>
@ -55,18 +59,25 @@ using namespace pcl::io;
using namespace std;
using namespace Reen;
// See
// http://www.ics.uci.edu/~gopi/PAPERS/Euro00.pdf
// http://www.ics.uci.edu/~gopi/PAPERS/CGMV.pdf
SurfaceTriangulation::SurfaceTriangulation(const Points::PointKernel& pts, Mesh::MeshObject& mesh)
: myPoints(pts), myMesh(mesh)
: myPoints(pts)
, myMesh(mesh)
, mu(0)
, searchRadius(0)
{
}
void SurfaceTriangulation::perform(double searchRadius, double mu)
void SurfaceTriangulation::perform(int ksearch)
{
PointCloud<PointXYZ>::Ptr cloud (new PointCloud<PointXYZ>);
PointCloud<PointNormal>::Ptr cloud_with_normals (new PointCloud<PointNormal>);
search::KdTree<PointXYZ>::Ptr tree;
search::KdTree<PointNormal>::Ptr tree2;
cloud->reserve(myPoints.size());
for (Points::PointKernel::const_iterator it = myPoints.begin(); it != myPoints.end(); ++it) {
cloud->push_back(PointXYZ(it->x, it->y, it->z));
}
@ -81,7 +92,7 @@ void SurfaceTriangulation::perform(double searchRadius, double mu)
n.setInputCloud (cloud);
//n.setIndices (indices[B);
n.setSearchMethod (tree);
n.setKSearch (20);
n.setKSearch (ksearch);
n.compute (*normals);
// Concatenate XYZ and normal information
@ -104,6 +115,61 @@ void SurfaceTriangulation::perform(double searchRadius, double mu)
gp3.setMinimumAngle(M_PI/18); // 10 degrees
gp3.setMaximumAngle(2*M_PI/3); // 120 degrees
gp3.setNormalConsistency(false);
gp3.setConsistentVertexOrdering(true);
// Reconstruct
PolygonMesh mesh;
gp3.reconstruct (mesh);
MeshConversion::convert(mesh, myMesh);
// Additional vertex information
//std::vector<int> parts = gp3.getPartIDs();
//std::vector<int> states = gp3.getPointStates();
}
void SurfaceTriangulation::perform(const std::vector<Base::Vector3f>& normals)
{
if (myPoints.size() != normals.size())
throw Base::RuntimeError("Number of points doesn't match with number of normals");
PointCloud<PointNormal>::Ptr cloud_with_normals (new PointCloud<PointNormal>);
search::KdTree<PointNormal>::Ptr tree;
cloud_with_normals->reserve(myPoints.size());
std::size_t num_points = myPoints.size();
const std::vector<Base::Vector3f>& points = myPoints.getBasicPoints();
for (std::size_t index=0; index<num_points; index++) {
const Base::Vector3f& p = points[index];
const Base::Vector3f& n = normals[index];
PointNormal pn;
pn.x = p.x;
pn.y = p.y;
pn.z = p.z;
pn.normal_x = n.x;
pn.normal_y = n.y;
pn.normal_z = n.z;
cloud_with_normals->push_back(pn);
}
// Create search tree
tree.reset (new search::KdTree<PointNormal>);
tree->setInputCloud (cloud_with_normals);
// Init objects
GreedyProjectionTriangulation<PointNormal> gp3;
// Set parameters
gp3.setInputCloud (cloud_with_normals);
gp3.setSearchMethod (tree);
gp3.setSearchRadius (searchRadius);
gp3.setMu (mu);
gp3.setMaximumNearestNeighbors (100);
gp3.setMaximumSurfaceAngle(M_PI/4); // 45 degrees
gp3.setMinimumAngle(M_PI/18); // 10 degrees
gp3.setMaximumAngle(2*M_PI/3); // 120 degrees
gp3.setNormalConsistency(true);
gp3.setConsistentVertexOrdering(true);
// Reconstruct
PolygonMesh mesh;
@ -136,6 +202,7 @@ void PoissonReconstruction::perform(int ksearch)
search::KdTree<PointXYZ>::Ptr tree;
search::KdTree<PointNormal>::Ptr tree2;
cloud->reserve(myPoints.size());
for (Points::PointKernel::const_iterator it = myPoints.begin(); it != myPoints.end(); ++it) {
cloud->push_back(PointXYZ(it->x, it->y, it->z));
}
@ -180,6 +247,449 @@ void PoissonReconstruction::perform(int ksearch)
MeshConversion::convert(mesh, myMesh);
}
void PoissonReconstruction::perform(const std::vector<Base::Vector3f>& normals)
{
if (myPoints.size() != normals.size())
throw Base::RuntimeError("Number of points doesn't match with number of normals");
PointCloud<PointNormal>::Ptr cloud_with_normals (new PointCloud<PointNormal>);
search::KdTree<PointNormal>::Ptr tree;
cloud_with_normals->reserve(myPoints.size());
std::size_t num_points = myPoints.size();
const std::vector<Base::Vector3f>& points = myPoints.getBasicPoints();
for (std::size_t index=0; index<num_points; index++) {
const Base::Vector3f& p = points[index];
const Base::Vector3f& n = normals[index];
PointNormal pn;
pn.x = p.x;
pn.y = p.y;
pn.z = p.z;
pn.normal_x = n.x;
pn.normal_y = n.y;
pn.normal_z = n.z;
cloud_with_normals->push_back(pn);
}
// Create search tree
tree.reset (new search::KdTree<PointNormal>);
tree->setInputCloud (cloud_with_normals);
// Init objects
Poisson<PointNormal> poisson;
// Set parameters
poisson.setInputCloud (cloud_with_normals);
poisson.setSearchMethod (tree);
if (depth >= 1)
poisson.setDepth(depth);
if (solverDivide >= 1)
poisson.setSolverDivide(solverDivide);
if (samplesPerNode >= 1.0f)
poisson.setSamplesPerNode(samplesPerNode);
// Reconstruct
PolygonMesh mesh;
poisson.reconstruct (mesh);
MeshConversion::convert(mesh, myMesh);
}
// ----------------------------------------------------------------------------
GridReconstruction::GridReconstruction(const Points::PointKernel& pts, Mesh::MeshObject& mesh)
: myPoints(pts)
, myMesh(mesh)
{
}
void GridReconstruction::perform(int ksearch)
{
PointCloud<PointXYZ>::Ptr cloud (new PointCloud<PointXYZ>);
PointCloud<PointNormal>::Ptr cloud_with_normals (new PointCloud<PointNormal>);
search::KdTree<PointXYZ>::Ptr tree;
search::KdTree<PointNormal>::Ptr tree2;
cloud->reserve(myPoints.size());
for (Points::PointKernel::const_iterator it = myPoints.begin(); it != myPoints.end(); ++it) {
cloud->push_back(PointXYZ(it->x, it->y, it->z));
}
// Create search tree
tree.reset (new search::KdTree<PointXYZ> (false));
tree->setInputCloud (cloud);
// Normal estimation
NormalEstimation<PointXYZ, Normal> n;
PointCloud<Normal>::Ptr normals (new PointCloud<Normal> ());
n.setInputCloud (cloud);
//n.setIndices (indices[B);
n.setSearchMethod (tree);
n.setKSearch (ksearch);
n.compute (*normals);
// Concatenate XYZ and normal information
pcl::concatenateFields (*cloud, *normals, *cloud_with_normals);
// Create search tree
tree2.reset (new search::KdTree<PointNormal>);
tree2->setInputCloud (cloud_with_normals);
// Init objects
GridProjection<PointNormal> grid;
// Set parameters
grid.setResolution(0.005);
grid.setPaddingSize(3);
grid.setNearestNeighborNum(100);
grid.setMaxBinarySearchLevel(10);
grid.setInputCloud (cloud_with_normals);
grid.setSearchMethod (tree2);
// Reconstruct
PolygonMesh mesh;
grid.reconstruct (mesh);
MeshConversion::convert(mesh, myMesh);
}
void GridReconstruction::perform(const std::vector<Base::Vector3f>& normals)
{
if (myPoints.size() != normals.size())
throw Base::RuntimeError("Number of points doesn't match with number of normals");
PointCloud<PointNormal>::Ptr cloud_with_normals (new PointCloud<PointNormal>);
search::KdTree<PointNormal>::Ptr tree;
cloud_with_normals->reserve(myPoints.size());
std::size_t num_points = myPoints.size();
const std::vector<Base::Vector3f>& points = myPoints.getBasicPoints();
for (std::size_t index=0; index<num_points; index++) {
const Base::Vector3f& p = points[index];
const Base::Vector3f& n = normals[index];
PointNormal pn;
pn.x = p.x;
pn.y = p.y;
pn.z = p.z;
pn.normal_x = n.x;
pn.normal_y = n.y;
pn.normal_z = n.z;
cloud_with_normals->push_back(pn);
}
// Create search tree
tree.reset (new search::KdTree<PointNormal>);
tree->setInputCloud (cloud_with_normals);
// Init objects
GridProjection<PointNormal> grid;
// Set parameters
grid.setResolution(0.005);
grid.setPaddingSize(3);
grid.setNearestNeighborNum(100);
grid.setMaxBinarySearchLevel(10);
grid.setInputCloud (cloud_with_normals);
grid.setSearchMethod (tree);
// Reconstruct
PolygonMesh mesh;
grid.reconstruct (mesh);
MeshConversion::convert(mesh, myMesh);
}
// ----------------------------------------------------------------------------
ImageTriangulation::ImageTriangulation(int width, int height, const Points::PointKernel& pts, Mesh::MeshObject& mesh)
: width(width)
, height(height)
, myPoints(pts)
, myMesh(mesh)
{
}
void ImageTriangulation::perform()
{
if (myPoints.size() != width * height)
throw Base::RuntimeError("Number of points doesn't match with given width and height");
//construct dataset
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_organized (new pcl::PointCloud<pcl::PointXYZ> ());
cloud_organized->width = width;
cloud_organized->height = height;
cloud_organized->points.resize (cloud_organized->width * cloud_organized->height);
const std::vector<Base::Vector3f>& points = myPoints.getBasicPoints();
int npoints = 0;
for (size_t i = 0; i < cloud_organized->height; i++) {
for (size_t j = 0; j < cloud_organized->width; j++) {
const Base::Vector3f& p = points[npoints];
cloud_organized->points[npoints].x = p.x;
cloud_organized->points[npoints].y = p.y;
cloud_organized->points[npoints].z = p.z;
npoints++;
}
}
OrganizedFastMesh<PointXYZ> ofm;
// Set parameters
ofm.setInputCloud (cloud_organized);
// This parameter is not yet implmented (pcl 1.7)
ofm.setMaxEdgeLength (1.5);
ofm.setTrianglePixelSize (1);
ofm.setTriangulationType (OrganizedFastMesh<PointXYZ>::TRIANGLE_ADAPTIVE_CUT);
ofm.storeShadowedFaces(true);
// Reconstruct
PolygonMesh mesh;
ofm.reconstruct (mesh);
MeshConversion::convert(mesh, myMesh);
// remove invalid points
//
MeshCore::MeshKernel& kernel = myMesh.getKernel();
const MeshCore::MeshFacetArray& face = kernel.GetFacets();
MeshCore::MeshAlgorithm meshAlg(kernel);
meshAlg.SetPointFlag(MeshCore::MeshPoint::INVALID);
std::vector<unsigned long> validPoints;
validPoints.reserve(face.size()*3);
for (MeshCore::MeshFacetArray::_TConstIterator it = face.begin(); it != face.end(); ++it) {
validPoints.push_back(it->_aulPoints[0]);
validPoints.push_back(it->_aulPoints[1]);
validPoints.push_back(it->_aulPoints[2]);
}
// remove duplicates
std::sort(validPoints.begin(), validPoints.end());
validPoints.erase(std::unique(validPoints.begin(), validPoints.end()), validPoints.end());
meshAlg.ResetPointsFlag(validPoints, MeshCore::MeshPoint::INVALID);
unsigned long countInvalid = meshAlg.CountPointFlag(MeshCore::MeshPoint::INVALID);
if (countInvalid > 0) {
std::vector<unsigned long> invalidPoints;
invalidPoints.reserve(countInvalid);
meshAlg.GetPointsFlag(invalidPoints, MeshCore::MeshPoint::INVALID);
kernel.DeletePoints(invalidPoints);
}
}
// ----------------------------------------------------------------------------
Reen::MarchingCubesRBF::MarchingCubesRBF(const Points::PointKernel& pts, Mesh::MeshObject& mesh)
: myPoints(pts)
, myMesh(mesh)
{
}
void Reen::MarchingCubesRBF::perform(int ksearch)
{
PointCloud<PointXYZ>::Ptr cloud (new PointCloud<PointXYZ>);
PointCloud<PointNormal>::Ptr cloud_with_normals (new PointCloud<PointNormal>);
search::KdTree<PointXYZ>::Ptr tree;
search::KdTree<PointNormal>::Ptr tree2;
cloud->reserve(myPoints.size());
for (Points::PointKernel::const_iterator it = myPoints.begin(); it != myPoints.end(); ++it) {
cloud->push_back(PointXYZ(it->x, it->y, it->z));
}
// Create search tree
tree.reset (new search::KdTree<PointXYZ> (false));
tree->setInputCloud (cloud);
// Normal estimation
NormalEstimation<PointXYZ, Normal> n;
PointCloud<Normal>::Ptr normals (new PointCloud<Normal> ());
n.setInputCloud (cloud);
//n.setIndices (indices[B);
n.setSearchMethod (tree);
n.setKSearch (ksearch);
n.compute (*normals);
// Concatenate XYZ and normal information
pcl::concatenateFields (*cloud, *normals, *cloud_with_normals);
// Create search tree
tree2.reset (new search::KdTree<PointNormal>);
tree2->setInputCloud (cloud_with_normals);
// Init objects
pcl::MarchingCubesRBF<PointNormal> rbf;
// Set parameters
rbf.setIsoLevel (0);
rbf.setGridResolution (60, 60, 60);
rbf.setPercentageExtendGrid (0.1f);
rbf.setOffSurfaceDisplacement (0.02f);
rbf.setInputCloud (cloud_with_normals);
rbf.setSearchMethod (tree2);
// Reconstruct
PolygonMesh mesh;
rbf.reconstruct (mesh);
MeshConversion::convert(mesh, myMesh);
}
void Reen::MarchingCubesRBF::perform(const std::vector<Base::Vector3f>& normals)
{
if (myPoints.size() != normals.size())
throw Base::RuntimeError("Number of points doesn't match with number of normals");
PointCloud<PointNormal>::Ptr cloud_with_normals (new PointCloud<PointNormal>);
search::KdTree<PointNormal>::Ptr tree;
cloud_with_normals->reserve(myPoints.size());
std::size_t num_points = myPoints.size();
const std::vector<Base::Vector3f>& points = myPoints.getBasicPoints();
for (std::size_t index=0; index<num_points; index++) {
const Base::Vector3f& p = points[index];
const Base::Vector3f& n = normals[index];
PointNormal pn;
pn.x = p.x;
pn.y = p.y;
pn.z = p.z;
pn.normal_x = n.x;
pn.normal_y = n.y;
pn.normal_z = n.z;
cloud_with_normals->push_back(pn);
}
// Create search tree
tree.reset (new search::KdTree<PointNormal>);
tree->setInputCloud (cloud_with_normals);
// Init objects
pcl::MarchingCubesRBF<PointNormal> rbf;
// Set parameters
rbf.setIsoLevel (0);
rbf.setGridResolution (60, 60, 60);
rbf.setPercentageExtendGrid (0.1f);
rbf.setOffSurfaceDisplacement (0.02f);
rbf.setInputCloud (cloud_with_normals);
rbf.setSearchMethod (tree);
// Reconstruct
PolygonMesh mesh;
rbf.reconstruct (mesh);
MeshConversion::convert(mesh, myMesh);
}
// ----------------------------------------------------------------------------
Reen::MarchingCubesHoppe::MarchingCubesHoppe(const Points::PointKernel& pts, Mesh::MeshObject& mesh)
: myPoints(pts)
, myMesh(mesh)
{
}
void Reen::MarchingCubesHoppe::perform(int ksearch)
{
PointCloud<PointXYZ>::Ptr cloud (new PointCloud<PointXYZ>);
PointCloud<PointNormal>::Ptr cloud_with_normals (new PointCloud<PointNormal>);
search::KdTree<PointXYZ>::Ptr tree;
search::KdTree<PointNormal>::Ptr tree2;
cloud->reserve(myPoints.size());
for (Points::PointKernel::const_iterator it = myPoints.begin(); it != myPoints.end(); ++it) {
cloud->push_back(PointXYZ(it->x, it->y, it->z));
}
// Create search tree
tree.reset (new search::KdTree<PointXYZ> (false));
tree->setInputCloud (cloud);
// Normal estimation
NormalEstimation<PointXYZ, Normal> n;
PointCloud<Normal>::Ptr normals (new PointCloud<Normal> ());
n.setInputCloud (cloud);
//n.setIndices (indices[B);
n.setSearchMethod (tree);
n.setKSearch (ksearch);
n.compute (*normals);
// Concatenate XYZ and normal information
pcl::concatenateFields (*cloud, *normals, *cloud_with_normals);
// Create search tree
tree2.reset (new search::KdTree<PointNormal>);
tree2->setInputCloud (cloud_with_normals);
// Init objects
pcl::MarchingCubesHoppe<PointNormal> hoppe;
// Set parameters
hoppe.setIsoLevel (0);
hoppe.setGridResolution (60, 60, 60);
hoppe.setPercentageExtendGrid (0.1f);
hoppe.setInputCloud (cloud_with_normals);
hoppe.setSearchMethod (tree2);
// Reconstruct
PolygonMesh mesh;
hoppe.reconstruct (mesh);
MeshConversion::convert(mesh, myMesh);
}
void Reen::MarchingCubesHoppe::perform(const std::vector<Base::Vector3f>& normals)
{
if (myPoints.size() != normals.size())
throw Base::RuntimeError("Number of points doesn't match with number of normals");
PointCloud<PointNormal>::Ptr cloud_with_normals (new PointCloud<PointNormal>);
search::KdTree<PointNormal>::Ptr tree;
cloud_with_normals->reserve(myPoints.size());
std::size_t num_points = myPoints.size();
const std::vector<Base::Vector3f>& points = myPoints.getBasicPoints();
for (std::size_t index=0; index<num_points; index++) {
const Base::Vector3f& p = points[index];
const Base::Vector3f& n = normals[index];
PointNormal pn;
pn.x = p.x;
pn.y = p.y;
pn.z = p.z;
pn.normal_x = n.x;
pn.normal_y = n.y;
pn.normal_z = n.z;
cloud_with_normals->push_back(pn);
}
// Create search tree
tree.reset (new search::KdTree<PointNormal>);
tree->setInputCloud (cloud_with_normals);
// Init objects
pcl::MarchingCubesHoppe<PointNormal> hoppe;
// Set parameters
hoppe.setIsoLevel (0);
hoppe.setGridResolution (60, 60, 60);
hoppe.setPercentageExtendGrid (0.1f);
hoppe.setInputCloud (cloud_with_normals);
hoppe.setSearchMethod (tree);
// Reconstruct
PolygonMesh mesh;
hoppe.reconstruct (mesh);
MeshConversion::convert(mesh, myMesh);
}
// ----------------------------------------------------------------------------
void MeshConversion::convert(const pcl::PolygonMesh& pclMesh, Mesh::MeshObject& meshObject)

101
src/Mod/ReverseEngineering/App/SurfaceTriangulation.h
View File

@ -24,6 +24,9 @@
#ifndef REEN_SURFACETRIANGULATION_H
#define REEN_SURFACETRIANGULATION_H
#include <Base/Vector3D.h>
#include <vector>
namespace Points {class PointKernel;}
namespace Mesh {class MeshObject;}
namespace pcl {struct PolygonMesh;}
@ -40,18 +43,48 @@ class SurfaceTriangulation
{
public:
SurfaceTriangulation(const Points::PointKernel&, Mesh::MeshObject&);
void perform(double searchRadius, double mu);
/** \brief Set the number of k nearest neighbors to use for the normal estimation.
* \param[in] k the number of k-nearest neighbors
*/
void perform(int ksearch);
/** \brief Pass the normals to the points given in the constructor.
* \param[in] normals the normals to the given points.
*/
void perform(const std::vector<Base::Vector3f>& normals);
/** \brief Set the multiplier of the nearest neighbor distance to obtain the final search radius for each point
* (this will make the algorithm adapt to different point densities in the cloud).
* \param[in] mu the multiplier
*/
inline void
setMu (double mu) { this->mu = mu; }
/** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors used for triangulating.
* \param[in] radius the sphere radius that is to contain all k-nearest neighbors
* \note This distance limits the maximum edge length!
*/
inline void
setSearchRadius (double radius) { this->searchRadius = radius; }
private:
const Points::PointKernel& myPoints;
Mesh::MeshObject& myMesh;
double mu;
double searchRadius;
};
class PoissonReconstruction
{
public:
PoissonReconstruction(const Points::PointKernel&, Mesh::MeshObject&);
/** \brief Set the number of k nearest neighbors to use for the normal estimation.
* \param[in] k the number of k-nearest neighbors
*/
void perform(int ksearch=5);
/** \brief Pass the normals to the points given in the constructor.
* \param[in] normals the normals to the given points.
*/
void perform(const std::vector<Base::Vector3f>& normals);
/** \brief Set the maximum depth of the tree that will be used for surface reconstruction.
* \note Running at depth d corresponds to solving on a voxel grid whose resolution is no larger than
@ -88,6 +121,72 @@ private:
float samplesPerNode;
};
class GridReconstruction
{
public:
GridReconstruction(const Points::PointKernel&, Mesh::MeshObject&);
/** \brief Set the number of k nearest neighbors to use for the normal estimation.
* \param[in] k the number of k-nearest neighbors
*/
void perform(int ksearch=5);
/** \brief Pass the normals to the points given in the constructor.
* \param[in] normals the normals to the given points.
*/
void perform(const std::vector<Base::Vector3f>& normals);
private:
const Points::PointKernel& myPoints;
Mesh::MeshObject& myMesh;
};
class ImageTriangulation
{
public:
ImageTriangulation(int width, int height, const Points::PointKernel&, Mesh::MeshObject&);
void perform();
private:
int width, height;
const Points::PointKernel& myPoints;
Mesh::MeshObject& myMesh;
};
class MarchingCubesRBF
{
public:
MarchingCubesRBF(const Points::PointKernel&, Mesh::MeshObject&);
/** \brief Set the number of k nearest neighbors to use for the normal estimation.
* \param[in] k the number of k-nearest neighbors
*/
void perform(int ksearch=5);
/** \brief Pass the normals to the points given in the constructor.
* \param[in] normals the normals to the given points.
*/
void perform(const std::vector<Base::Vector3f>& normals);
private:
const Points::PointKernel& myPoints;
Mesh::MeshObject& myMesh;
};
class MarchingCubesHoppe
{
public:
MarchingCubesHoppe(const Points::PointKernel&, Mesh::MeshObject&);
/** \brief Set the number of k nearest neighbors to use for the normal estimation.
* \param[in] k the number of k-nearest neighbors
*/
void perform(int ksearch=5);
/** \brief Pass the normals to the points given in the constructor.
* \param[in] normals the normals to the given points.
*/
void perform(const std::vector<Base::Vector3f>& normals);
private:
const Points::PointKernel& myPoints;
Mesh::MeshObject& myMesh;
};
} // namespace Reen
#endif // REEN_SURFACETRIANGULATION_H