polyhedron cgal_to_polyhedron( const Nef_polyhedron &NP ){
Polyhedron P;
polyhedron ret;
if( NP.is_simple() ){
NP.convert_to_polyhedron(P);
std::vector<double> coords;
std::vector<int> tris;
int next_id = 0;
std::map< Polyhedron::Vertex*, int > vid;
for( Polyhedron::Vertex_iterator iter=P.vertices_begin(); iter!=P.vertices_end(); iter++ ){
coords.push_back( CGAL::to_double( (*iter).point().x() ) );
coords.push_back( CGAL::to_double( (*iter).point().y() ) );
coords.push_back( CGAL::to_double( (*iter).point().z() ) );
vid[ &(*iter) ] = next_id++;
}
for( Polyhedron::Facet_iterator iter=P.facets_begin(); iter!=P.facets_end(); iter++ ){
Polyhedron::Halfedge_around_facet_circulator j = iter->facet_begin();
tris.push_back( CGAL::circulator_size(j) );
do {
tris.push_back( std::distance(P.vertices_begin(), j->vertex()) );
} while ( ++j != iter->facet_begin());
}
ret.initialize_load_from_mesh( coords, tris );
} else {
std::cout << "resulting polyhedron is not simple!" << std::endl;
}
return ret;
}
void smoothMesh( Polyhedron & poly, unsigned int nTimes )
{
int nV = poly.size_of_vertices();
const double lambda = SMOOTHING_LAMBDA;
const double mu = SMOOTHING_MU;
vector< Point3 > shrink ( nV );
vector< Point3 > expand ( nV );
for ( unsigned int k = 0; k < nTimes; ++k ) {
// copy the vertex coordinates
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
shrink [ vi->id() ] = vi->point();
}
// shrinking stage
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
moveVertex( vi, shrink[ vi->id() ], lambda );
}
// copy back the vertex coordinates
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
vi->point() = shrink[ vi->id() ];
expand[ vi->id() ] = shrink[ vi->id() ];
}
// expanding stage
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
moveVertex( vi, expand[ vi->id() ], mu );
}
// copy back the vertex coordinates
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
vi->point() = expand[ vi->id() ];
}
}
}
void geometryUtils::subdivide(Polyhedron& P) {
if (P.size_of_facets() == 0)
return;
// We use that new vertices/halfedges/facets are appended at the end.
std::size_t nv = P.size_of_vertices();
Vertex_iterator last_v = P.vertices_end();
--last_v; // the last of the old vertices
Edge_iterator last_e = P.edges_end();
--last_e; // the last of the old edges
Facet_iterator last_f = P.facets_end();
--last_f; // the last of the old facets
Facet_iterator f = P.facets_begin(); // create new center vertices
do {
geometryUtils::subdivide_create_center_vertex(P, f);
} while (f++ != last_f);
std::vector<Point_3> pts; // smooth the old vertices
pts.reserve(nv); // get intermediate space for the new points
++last_v; // make it the past-the-end position again
std::transform(P.vertices_begin(), last_v, std::back_inserter(pts),
Smooth_old_vertex());
std::copy(pts.begin(), pts.end(), P.points_begin());
Edge_iterator e = P.edges_begin(); // flip the old edges
++last_e; // make it the past-the-end position again
while (e != last_e) {
Halfedge_handle h = e;
++e; // careful, incr. before flip since flip destroys current edge
geometryUtils::subdivide_flip_edge(P, h);
};
CGAL_postcondition(P.is_valid());
};
void renewAttrs( Polyhedron & poly )
{
// assign IDs to vertices
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
vi->nCuts() = 0;
}
// assign IDs to faces: the dual vertex and the dual coordinates-the center coordinates
for ( Facet_iterator fi = poly.facets_begin(); fi != poly.facets_end(); ++fi ) {
fi->piece() = NO_INDEX;
Vector3 sum( 0.0, 0.0, 0.0 );
Halfedge_facet_circulator hfc = fi->facet_begin();
do {
sum = sum + ( hfc->vertex()->point() - CGAL::ORIGIN );
} while ( ++hfc != fi->facet_begin() );
sum = sum / ( double )CGAL::circulator_size( hfc );
fi->center() = CGAL::ORIGIN + sum;
}
// assign the same IDs to the identical/ opposite halfedges
for ( Halfedge_iterator hi = poly.halfedges_begin(); hi != poly.halfedges_end(); ++hi ) {
hi->label() = DEFAULT_LABEL;
hi->match() = DEFAULT_LABEL;
hi->cycle() = NO_INDEX;
hi->connect() = true;
hi->visit() = false;
hi->path() = NO_INDEX;
hi->orient() = true;
// We individually handle hi->fixed
}
}
void transformMesh( Polyhedron & poly, Transformation3 & map )
{
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
Point3 store = vi->point().transform( map );
vi->point() = store;
}
}
//------------------------------------------------------------------------------
// Initialize the dual center
//------------------------------------------------------------------------------
void initAttrs( Polyhedron & poly )
{
// assign IDs to vertices
int vID = 0;
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
vi->id() = vID++;
vi->label() = DEFAULT_LABEL;
vi->nCuts() = 0;
}
cerr << "Total number of vertices = " << vID << endl;
// assign IDs to faces: the dual vertex and the dual coordinates-the center coordinates
int fID = 0;
for ( Facet_iterator fi = poly.facets_begin(); fi != poly.facets_end(); ++fi ) {
fi->id() = fID++;
// fi->label() = DEFAULT_LABEL;
fi->piece() = NO_INDEX;
Vector3 sum( 0.0, 0.0, 0.0 );
Halfedge_facet_circulator hfc = fi->facet_begin();
do {
sum = sum + ( hfc->vertex()->point() - CGAL::ORIGIN );
} while ( ++hfc != fi->facet_begin() );
sum = sum / ( double )CGAL::circulator_size( hfc );
fi->center() = CGAL::ORIGIN + sum;
// cerr << " Barycenter No. " << fid-1 << " : " << bary[ fid-1 ] << endl;
}
cerr << "Total number of facets = " << fID << endl;
// initialize the halfedge IDs
for ( Halfedge_iterator hi = poly.halfedges_begin(); hi != poly.halfedges_end(); ++hi ) {
hi->id() = NO_INDEX;
}
// assign the same IDs to the identical/ opposite halfedges
int eID = 0;
for ( Halfedge_iterator hi = poly.halfedges_begin(); hi != poly.halfedges_end(); ++hi ) {
if ( hi->id() == NO_INDEX ) {
assert( hi->opposite()->id() == NO_INDEX );
hi->id() = eID;
hi->opposite()->id() = eID;
eID++;
hi->label() = hi->opposite()->label() = DEFAULT_LABEL;
hi->match() = hi->opposite()->match() = DEFAULT_LABEL;
hi->cycle() = hi->opposite()->cycle() = NO_INDEX;
hi->weight() = hi->opposite()->weight() = 0.0;
hi->connect() = hi->opposite()->connect() = true;
hi->visit() = hi->opposite()->visit() = false;
// We individually handle hi->fixed
}
}
cerr << "Total number of edges = " << eID << endl;
}
int main()
{
std::stringstream ss;
ss << "\
OFF\n6 4 0\n\
0 1 0\n\
0 0 0\n\
1 0 0\n\
1 1 0\n\
2 1 0\n\
2 0 0\n\
3 0 1 2\n\
3 0 2 3\n\
3 2 5 3\n\
3 5 4 3\n";
Polyhedron P;
ss >> P;
assert( P.size_of_vertices() == 6);
assert( P.size_of_facets() == 4);
assert( P.is_valid() );
//consider vertex 3 and set its halfedge to be on the border
Polyhedron::Vertex_iterator vit=P.vertices_begin();
std::advance(vit, 3);
assert( vit->point() == K::Point_3(1, 1, 0) );
Polyhedron::Halfedge_handle h=vit->halfedge();
while ( !h->is_border() )
h=h->next()->opposite();
vit->VBase::set_halfedge(h);
assert( vit->halfedge()->vertex() == vit );
//consider vertex 4 and set its halfedge to be on the border
++vit;
assert( vit->point() == K::Point_3(2, 1, 0) );
h=vit->halfedge();
while ( !h->is_border() )
h=h->next()->opposite();
vit->VBase::set_halfedge(h);
assert( vit->halfedge()->vertex() == vit );
//try to append a facet
Appender modifier;
P.delegate(modifier);
assert( P.size_of_vertices() == 7);
assert( P.size_of_facets() == 5);
assert( P.is_valid() );
}
//------------------------------------------------------------------------------
// Normalize the 3D triangulated mesh with the display window
//------------------------------------------------------------------------------
void normalizeMesh( Polyhedron & poly, vector< Segment3 > & bone )
{
Vector3 sum, ave;
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
sum = sum + ( vi->point() - CGAL::ORIGIN );
}
ave = sum / ( double )poly.size_of_vertices();
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
vi->point() = vi->point() - ave;
}
cerr << " ave = " << ave << endl;
Transformation3 translate( CGAL::TRANSLATION, -ave );
// fabs:absolute values-no negative values
double sideMax = 0.0;
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
if ( fabs( vi->point().x() ) > sideMax ) sideMax = fabs( vi->point().x() );
if ( fabs( vi->point().y() ) > sideMax ) sideMax = fabs( vi->point().y() );
if ( fabs( vi->point().z() ) > sideMax ) sideMax = fabs( vi->point().z() );
}
// sideMax: the largest number
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
vi->point() = CGAL::ORIGIN + ( vi->point() - CGAL::ORIGIN ) / sideMax;
}
Transformation3 scale( CGAL::SCALING, 1.0/sideMax );
Transformation3 composite = scale * translate;
for ( unsigned int k = 0; k < bone.size(); ++k ) {
bone[ k ] = bone[ k ].transform( composite );
}
}
void modify_vertex_position()
{
Polyhedron P;
Halfedge_handle h = P.make_tetrahedron();
if ( P.is_tetrahedron(h))
{
int i(0);
for(Vertex_iterator vi = P.vertices_begin(); vi != P.vertices_end(); ++vi,++i)
{
std::cout << "before changing vertex " << i << ": " << vi->point().x() << vi->point().y() << vi->point().z() << endl;
Point_3 pt(1, 0, 0);
vi->point() = pt;
std::cout << "after changing vertex " << i << ": " << vi->point().x() << vi->point().y() << vi->point().z() << endl;
}
}
}
IGL_INLINE void igl::copyleft::cgal::polyhedron_to_mesh(
const Polyhedron & poly,
Eigen::MatrixXd & V,
Eigen::MatrixXi & F)
{
using namespace std;
V.resize(poly.size_of_vertices(),3);
F.resize(poly.size_of_facets(),3);
typedef typename Polyhedron::Vertex_const_iterator Vertex_iterator;
std::map<Vertex_iterator,size_t> vertex_to_index;
{
size_t v = 0;
for(
typename Polyhedron::Vertex_const_iterator p = poly.vertices_begin();
p != poly.vertices_end();
p++)
{
V(v,0) = p->point().x();
V(v,1) = p->point().y();
V(v,2) = p->point().z();
vertex_to_index[p] = v;
v++;
}
}
{
size_t f = 0;
for(
typename Polyhedron::Facet_const_iterator facet = poly.facets_begin();
facet != poly.facets_end();
++facet)
{
typename Polyhedron::Halfedge_around_facet_const_circulator he =
facet->facet_begin();
// Facets in polyhedral surfaces are at least triangles.
assert(CGAL::circulator_size(he) == 3 && "Facets should be triangles");
size_t c = 0;
do {
//// This is stooopidly slow
// F(f,c) = std::distance(poly.vertices_begin(), he->vertex());
F(f,c) = vertex_to_index[he->vertex()];
c++;
} while ( ++he != facet->facet_begin());
f++;
}
}
}
scalarField calcCurvature(const triSurface& surf)
{
scalarField k(surf.points().size(), 0);
Polyhedron P;
buildCGALPolyhedron convert(surf);
P.delegate(convert);
// Info<< "Created CGAL Polyhedron with " << label(P.size_of_vertices())
// << " vertices and " << label(P.size_of_facets())
// << " facets. " << endl;
// The rest of this function adapted from
// CGAL-3.7/examples/Jet_fitting_3/Mesh_estimation.cpp
//Vertex property map, with std::map
typedef std::map<Vertex*, int> Vertex2int_map_type;
typedef boost::associative_property_map< Vertex2int_map_type >
Vertex_PM_type;
typedef T_PolyhedralSurf_rings<Polyhedron, Vertex_PM_type > Poly_rings;
typedef CGAL::Monge_via_jet_fitting<Kernel> Monge_via_jet_fitting;
typedef Monge_via_jet_fitting::Monge_form Monge_form;
std::vector<Point_3> in_points; //container for data points
// default parameter values and global variables
unsigned int d_fitting = 2;
unsigned int d_monge = 2;
unsigned int min_nb_points = (d_fitting + 1)*(d_fitting + 2)/2;
//initialize the tag of all vertices to -1
Vertex_iterator vitb = P.vertices_begin();
Vertex_iterator vite = P.vertices_end();
Vertex2int_map_type vertex2props;
Vertex_PM_type vpm(vertex2props);
CGAL_For_all(vitb, vite)
{
put(vpm, &(*vitb), -1);
}
int main(int argc, const char **argv )
{
std::vector<Point> points;
CGAL::Random_points_on_sphere_3<Point> g;
size_t N = 0;
if (argc > 1)
N = atof(argv[1]);
N = std::max(size_t(100), N);
for (size_t i = 0; i < N; ++i)
points.push_back(rescale(*g++));
for (size_t n = 0; n < 100; ++n)
{
std::cerr << "step " << n << ":\n\t";
lloyd_step(points);
}
Polyhedron P;
CGAL::convex_hull_3(points.begin(), points.end(), P);
CGAL::set_ascii_mode( std::cout);
std::cout << "OFF" << std::endl << P.size_of_vertices() << ' '
<< P.size_of_facets() << " 0" << std::endl;
std::copy( P.points_begin(), P.points_end(),
std::ostream_iterator<Point>( std::cout, "\n"));
for ( Facet_iterator i = P.facets_begin(); i != P.facets_end(); ++i) {
Halfedge_facet_circulator j = i->facet_begin();
// Facets in polyhedral surfaces are at least triangles.
CGAL_assertion( CGAL::circulator_size(j) >= 3);
std::cout << CGAL::circulator_size(j) << ' ';
do {
std::cout << ' ' << std::distance(P.vertices_begin(), j->vertex());
} while ( ++j != i->facet_begin());
std::cout << std::endl;
}
std::ofstream os ("test.cloud");
std::copy(points.begin(), points.end(),
std::ostream_iterator<Point>(os, "\n"));
}
//**********************************************************************************
//returns min coordinates
Vector3r MinCoord(const shared_ptr<Shape>& cm1,const State& state1){
const Se3r& se3=state1.se3;
Polyhedra* A = static_cast<Polyhedra*>(cm1.get());
//move and rotate CGAL structure Polyhedron
Matrix3r rot_mat = (se3.orientation).toRotationMatrix();
Vector3r trans_vec = se3.position;
Transformation t_rot_trans(rot_mat(0,0),rot_mat(0,1),rot_mat(0,2), trans_vec[0],rot_mat(1,0),rot_mat(1,1),rot_mat(1,2),trans_vec[1],rot_mat(2,0),rot_mat(2,1),rot_mat(2,2),trans_vec[2],1.);
Polyhedron PA = A->GetPolyhedron();
std::transform( PA.points_begin(), PA.points_end(), PA.points_begin(), t_rot_trans);
Vector3r minccord = trans_vec;
for(Polyhedron::Vertex_iterator vi = PA.vertices_begin(); vi != PA.vertices_end(); ++vi){
if (vi->point()[0]<minccord[0]) minccord[0]=vi->point()[0];
if (vi->point()[1]<minccord[1]) minccord[1]=vi->point()[1];
if (vi->point()[2]<minccord[2]) minccord[2]=vi->point()[2];
}
return minccord;
}
ofMesh & ofxCGALSkinSurface::makeSkinSurfaceMesh() {
std::list<Weighted_point> l;
FT shrinkfactor = shrinkFactor;
for(int i=0; i<points.size(); i++) {
float px = points[i].point.x;
float py = points[i].point.y;
float pz = points[i].point.z;
float radius = points[i].radius;
l.push_front(Weighted_point(Bare_point(px, py, pz), radius * radius));
}
Skin_surface_3 skin_surface(l.begin(), l.end(), shrinkfactor);
Polyhedron p;
CGAL::mesh_skin_surface_3(skin_surface, p);
if(bSubdiv == true) {
CGAL::subdivide_skin_surface_mesh_3(skin_surface, p);
}
mesh.clear();
map<Point_3, int> point_indices;
int count = 0;
for (auto it=p.vertices_begin(); it!=p.vertices_end(); ++it) {
auto& p = it->point();
mesh.addVertex(ofVec3f(p.x(), p.y(), p.z()));
point_indices[p] = count++;
}
for (auto it=p.facets_begin(); it!=p.facets_end(); ++it) {
mesh.addIndex(point_indices[it->halfedge()->vertex()->point()]);
mesh.addIndex(point_indices[it->halfedge()->next()->vertex()->point()]);
mesh.addIndex(point_indices[it->halfedge()->prev()->vertex()->point()]);
}
}
void alignMesh( Polyhedron & poly )
{
int num = poly.size_of_vertices();
// initialization here is very important!!
Point3 ave( 0.0, 0.0, 0.0 );
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
ave = ave + ( vi->point() - CGAL::ORIGIN );
}
ave = CGAL::ORIGIN + ( ave - CGAL::ORIGIN )/( double )num;
unsigned int dim = 3;
double * data = new double [ num*dim ];
int nPoints = 0;
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
data[ nPoints * dim + 0 ] = vi->point().x() - ave.x();
data[ nPoints * dim + 1 ] = vi->point().y() - ave.y();
data[ nPoints * dim + 2 ] = vi->point().z() - ave.z();
nPoints++;
}
assert( nPoints == ( int )num );
/*****************************************
analyze the engenstructure of X^T X
*****************************************/
/* define the matrix X */
gsl_matrix_view X = gsl_matrix_view_array( data, num, dim );
/* memory reallocation */
// proj = ( double * )realloc( proj, sizeof( double ) * PDIM * num );
/* calculate the covariance matrix B */
gsl_matrix * B = gsl_matrix_alloc( dim, dim );
gsl_blas_dgemm( CblasTrans, CblasNoTrans, 1.0,
&(X.matrix),
&(X.matrix), 0.0,
B );
/* divided by the number of samples */
gsl_matrix_scale( B, 1.0/(double)num );
gsl_vector * eVal = gsl_vector_alloc( dim );
gsl_matrix * eVec = gsl_matrix_alloc( dim, dim );
gsl_eigen_symmv_workspace * w
= gsl_eigen_symmv_alloc( dim );
// eigenanalysis of the matrix B
gsl_eigen_symmv( B, eVal, eVec, w );
// release the memory of w
gsl_eigen_symmv_free( w );
// sort eigenvalues in a descending order
gsl_eigen_symmv_sort( eVal, eVec, GSL_EIGEN_SORT_VAL_DESC );
// #ifdef MYDEBUG
for ( unsigned int i = 0; i < dim; ++i ) {
cerr << "Eigenvalue No. " << i << " = " << gsl_vector_get( eVal, i ) << endl;
cerr << "Eigenvector No. " << i << endl;
double length = 0.0;
for ( unsigned int j = 0; j < dim; ++j ) {
cerr << gsl_matrix_get( eVec, i, j ) << " ";
length += gsl_matrix_get( eVec, i, j )*gsl_matrix_get( eVec, i, j );
}
cerr << " length = " << length << endl;
}
// #endif // MYDEBUG
// 0 1 2, 0 2 1,
Transformation3 map;
map =
Transformation3( gsl_matrix_get(eVec,1,0), gsl_matrix_get(eVec,0,0), gsl_matrix_get(eVec,2,0),
gsl_matrix_get(eVec,1,1), gsl_matrix_get(eVec,0,1), gsl_matrix_get(eVec,2,1),
gsl_matrix_get(eVec,1,2), gsl_matrix_get(eVec,0,2), gsl_matrix_get(eVec,2,2) );
if ( map.is_odd() ) {
cerr << " Transformation matrix reflected" << endl;
map =
Transformation3( gsl_matrix_get(eVec,1,0), gsl_matrix_get(eVec,0,0), -gsl_matrix_get(eVec,2,0),
gsl_matrix_get(eVec,1,1), gsl_matrix_get(eVec,0,1), -gsl_matrix_get(eVec,2,1),
gsl_matrix_get(eVec,1,2), gsl_matrix_get(eVec,0,2), -gsl_matrix_get(eVec,2,2) );
}
for ( unsigned int i = 0; i < dim; ++i ) {
cerr << "| ";
for ( unsigned int j = 0; j < dim; ++j ) {
cerr << map.cartesian( i, j ) << " ";
}
cerr << "|" << endl;
}
transformMesh( poly, map );
return;
}
//------------------------------------------------------------------------------
// Align the mesh
//------------------------------------------------------------------------------
Vector3 principalAxis( Polyhedron & poly )
{
int num = poly.size_of_vertices();
// initialization here is very important!!
Point3 ave( 0.0, 0.0, 0.0 );
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
ave = ave + ( vi->point() - CGAL::ORIGIN );
}
ave = CGAL::ORIGIN + ( ave - CGAL::ORIGIN )/( double )num;
unsigned int dim = 3;
double * data = new double [ num*dim ];
int nPoints = 0;
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
data[ nPoints * dim + 0 ] = vi->point().x() - ave.x();
data[ nPoints * dim + 1 ] = vi->point().y() - ave.y();
data[ nPoints * dim + 2 ] = vi->point().z() - ave.z();
nPoints++;
}
assert( nPoints == ( int )num );
/*****************************************
analyze the engenstructure of X^T X
*****************************************/
/* define the matrix X */
gsl_matrix_view X = gsl_matrix_view_array( data, num, dim );
/* memory reallocation */
// proj = ( double * )realloc( proj, sizeof( double ) * PDIM * num );
/* calculate the covariance matrix B */
gsl_matrix * B = gsl_matrix_alloc( dim, dim );
gsl_blas_dgemm( CblasTrans, CblasNoTrans, 1.0,
&(X.matrix),
&(X.matrix), 0.0,
B );
/* divided by the number of samples */
gsl_matrix_scale( B, 1.0/(double)num );
gsl_vector * eVal = gsl_vector_alloc( dim );
gsl_matrix * eVec = gsl_matrix_alloc( dim, dim );
gsl_eigen_symmv_workspace * w
= gsl_eigen_symmv_alloc( dim );
// eigenanalysis of the matrix B
gsl_eigen_symmv( B, eVal, eVec, w );
// release the memory of w
gsl_eigen_symmv_free( w );
// sort eigenvalues in a descending order
gsl_eigen_symmv_sort( eVal, eVec, GSL_EIGEN_SORT_VAL_DESC );
#ifdef MYDEBUG
for ( unsigned int i = 0; i < dim; ++i ) {
cerr << "Eigenvalue No. " << i << " = " << gsl_vector_get( eVal, i ) << endl;
cerr << "Eigenvector No. " << i << endl;
for ( unsigned int j = 0; j < dim; ++j ) {
length += gsl_matrix_get( eVec, i, j )*gsl_matrix_get( eVec, i, j );
}
cerr << " length = " << length << endl;
}
#endif // MYDEBUG
Vector3 ref( gsl_matrix_get( eVec, 0, 0 ),
gsl_matrix_get( eVec, 0, 1 ),
gsl_matrix_get( eVec, 0, 2 ) );
return ref;
#ifdef DEBUG
gsl_vector_view eachVec = gsl_matrix_column( eigenVec, 0 );
double cosRot = gsl_matrix_get( eigenVec, 0, 1 );
double sinRot = gsl_matrix_get( eigenVec, 1, 1 );
#ifdef DEBUG
cerr << " 2nd axis : " << cosRot << " , " << sinRot << endl;
#endif // DEBUG
Transformation2 rotate( CGAL::ROTATION, -sinRot, cosRot );
for ( unsigned int i = 0; i < subpatch.size(); ++i ) {
subpatch[ i ]->triangle() = subpatch[ i ]->triangle().transform( rotate );
}
#endif // DEBUG
}
int main(int argc, char * argv[])
{
std::cerr << "PARAMETERIZATION" << std::endl;
std::cerr << " Floater parameterization" << std::endl;
std::cerr << " Circle border" << std::endl;
std::cerr << " Eigen solver" << std::endl;
//***************************************
// decode parameters
//***************************************
if (argc-1 != 1)
{
std::cerr << "Usage: " << argv[0] << " input_file.off" << std::endl;
return(EXIT_FAILURE);
}
// File name is:
const char* input_filename = argv[1];
//***************************************
// Read the mesh
//***************************************
// Read the mesh
std::ifstream stream(input_filename);
Polyhedron mesh;
stream >> mesh;
if(!stream || !mesh.is_valid() || mesh.empty())
{
std::cerr << "Error: cannot read OFF file " << input_filename << std::endl;
return EXIT_FAILURE;
}
//***************************************
// Create Polyhedron adaptor
// Note: no cutting => we support only
// meshes that are topological disks
//***************************************
typedef CGAL::Parameterization_polyhedron_adaptor_3<Polyhedron>
Parameterization_polyhedron_adaptor;
Timer t;
t.start();
Parameterization_polyhedron_adaptor mesh_adaptor(mesh);
//***************************************
// Floater Mean Value Coordinates parameterization
// (circular border) with Eigen solver
//***************************************
// Circular border parameterizer (the default)
typedef CGAL::Circular_border_arc_length_parameterizer_3<Parameterization_polyhedron_adaptor>
Border_parameterizer;
// Eigen solver
typedef CGAL::Eigen_solver_traits<Eigen::BiCGSTAB<CGAL::Eigen_sparse_matrix<double>::EigenType, Eigen::IncompleteLUT< double > > > Solver;
// Floater Mean Value Coordinates parameterization
// (circular border) with Eigen solver
typedef CGAL::Mean_value_coordinates_parameterizer_3<Parameterization_polyhedron_adaptor,
Border_parameterizer,
Solver>
Parameterizer;
Parameterizer::Error_code err = CGAL::parameterize(mesh_adaptor, Parameterizer());
t.stop();
switch(err) {
case Parameterizer::OK: // Success
break;
case Parameterizer::ERROR_EMPTY_MESH: // Input mesh not supported
case Parameterizer::ERROR_NON_TRIANGULAR_MESH:
case Parameterizer::ERROR_NO_TOPOLOGICAL_DISC:
case Parameterizer::ERROR_BORDER_TOO_SHORT:
std::cerr << "Input mesh not supported: " << Parameterizer::get_error_message(err) << std::endl;
return EXIT_FAILURE;
break;
default: // Error
std::cerr << "Error: " << Parameterizer::get_error_message(err) << std::endl;
return EXIT_FAILURE;
break;
};
//***************************************
// Output
//***************************************
// Raw output: dump (u,v) pairs
Polyhedron::Vertex_const_iterator pVertex;
for (pVertex = mesh.vertices_begin();
pVertex != mesh.vertices_end();
pVertex++)
{
// (u,v) pair is stored in any halfedge
double u = mesh_adaptor.info(pVertex->halfedge())->uv().x();
double v = mesh_adaptor.info(pVertex->halfedge())->uv().y();
std::cout << "(u,v) = (" << u << "," << v << ")" << std::endl;
}
std::cerr << t.time() << "sec." << std::endl;
return EXIT_SUCCESS;
}
void MainWindow::parameterize(const Parameterization_method method)
{
QApplication::setOverrideCursor(Qt::WaitCursor);
// get active polyhedron
int index = getSelectedSceneItemIndex();
Polyhedron* pMesh = scene->polyhedron(index);
if(pMesh == NULL)
{
QApplication::restoreOverrideCursor();
return;
}
// parameterize
QTime time;
time.start();
typedef CGAL::Parameterization_polyhedron_adaptor_3<Polyhedron> Adaptor;
Adaptor adaptor(*pMesh);
bool success = false;
switch(method)
{
case PARAM_MVC:
{
std::cout << "Parameterize (MVC)...";
typedef CGAL::Mean_value_coordinates_parameterizer_3<Adaptor> Parameterizer;
Parameterizer::Error_code err = CGAL::parameterize(adaptor,Parameterizer());
success = err == Parameterizer::OK;
break;
}
case PARAM_DCP:
{
std::cout << "Parameterize (DCP)...";
typedef CGAL::Discrete_conformal_map_parameterizer_3<Adaptor> Parameterizer;
Parameterizer::Error_code err = CGAL::parameterize(adaptor,Parameterizer());
success = err == Parameterizer::OK;
}
}
if(success)
std::cout << "ok (" << time.elapsed() << " ms)" << std::endl;
else
{
std::cout << "failure" << std::endl;
QApplication::restoreOverrideCursor();
return;
}
// add textured polyhedon to the scene
Textured_polyhedron *pTex_polyhedron = new Textured_polyhedron();
Textured_polyhedron_builder<Polyhedron,Textured_polyhedron,Kernel> builder;
builder.run(*pMesh,*pTex_polyhedron);
pTex_polyhedron->compute_normals();
Polyhedron::Vertex_iterator it1;
Textured_polyhedron::Vertex_iterator it2;
for(it1 = pMesh->vertices_begin(),
it2 = pTex_polyhedron->vertices_begin();
it1 != pMesh->vertices_end(),
it2 != pTex_polyhedron->vertices_end();
it1++, it2++)
{
// (u,v) pair is stored per halfedge
FT u = adaptor.info(it1->halfedge())->uv().x();
FT v = adaptor.info(it1->halfedge())->uv().y();
it2->u() = u;
it2->v() = v;
}
scene->addTexPolyhedron(pTex_polyhedron,
tr("%1 (parameterized)").arg(scene->polyhedronName(index)),
Qt::white,
scene->isPolyhedronVisible(index),
scene->polyhedronRenderingMode(index));
QApplication::restoreOverrideCursor();
}
void ComputeGaussCurvature(Polyhedron &P)
{
Polyhedron::Vertex_iterator vit;
for(vit=P.vertices_begin(); vit!=P.vertices_end(); vit++)
ComputeGaussCurvature(vit);
}
void ElPoly::DefineSkin(int NSample){
std::list<Weighted_point> l;
FT shrinkfactor = 0.5;
double *Plot = new double[pNType()*CUBE(NSample)];
double *Count = new double[CUBE(NSample)];
double Thre = 10.;
double Radius = pEdge(0)/(double)NSample;
for(int p=0;p<pNPart();p++){
int t = pType(p);
int vx = (int)(pPos(p,0)/pEdge(0)*NSample);
int vy = (int)(pPos(p,1)/pEdge(1)*NSample);
int vz = (int)(pPos(p,2)/pEdge(2)*NSample);
int vTot = (vz*NSample+vy)*NSample+vx;
Plot[vTot*pNType()+t] += 1.;
}
double *Norm = (double *)calloc(pNType(),sizeof(double));
for(int t=0;t<pNType();t++){
for(int v=0;v<CUBE(NSample);v++){
if(Norm[t] < Plot[v*pNType()+t])
Norm[t] = Plot[v*pNType()+t];
}
Norm[t] = Norm[t] <= 0. ? 1. : Norm[t];
}
for(int vx=0;vx<NSample;vx++){
double x = vx*pEdge(0)/(double)NSample;
for(int vy=0;vy<NSample;vy++){
double y = vy*pEdge(1)/(double)NSample;
for(int vz=0;vz<NSample;vz++){
double z = vz*pEdge(2)/(double)NSample;
int vTot = (vz*NSample+vy)*NSample+vx;
if(Plot[vTot*pNType()] > Thre){
l.push_front(Weighted_point(Bare_point(x,y,z),Radius));
}
}
}
}
Polyhedron Polyhe;
Skin_surface_3 skin_surface(l.begin(), l.end(), shrinkfactor);
CGAL::mesh_skin_surface_3(skin_surface, Polyhe);
// CGAL::subdivide_skin_surface_mesh_3(skin_surface, Polyhe);
// std::ofstream out("mesh.off");
// out << Polyhe;
glDeleteLists(Dr->Particles,1);
Dr->Particles = glGenLists(1);
glNewList(Dr->Particles,GL_COMPILE);
// Polyhedron::Facet_iterator fcUp = Polyhe.facets_begin();
// for(;fcUp != Polyhe.facets_end(); ++fcUp){
// Polyhedron::Supports_facet_halfedge = fcUp.halfedge();
// //Halfedge_around_facet_circulator heUp = fcUp.halfedge();
// }
// for (Vertex_iterator vit = Polyhe.vertices_begin();vit != Polyhe.vertices_end(); vit++){
// // Vector n = policy.normal(vit);
// // n = n/sqrt(n*n);
// cout << vit->point() << std::endl;
// Halfedge_iterator heUp = Polyhe.halfedges_begin();
// for(;heUp != Polyhe.halfedges_end(); ++heUp){
// //Polyhedron::Halfedge_handle Half = *heUp;
// Vertex_handle veUp = heUp->vertex();
// K::Point_3 pf1 = vit->point();
// }
// }
CGAL::Inverse_index<Vertex_handle> index(Polyhe.vertices_begin(),
Polyhe.vertices_end());
for(Facet_iterator fi = Polyhe.facets_begin();fi != Polyhe.facets_end(); ++fi) {
HFC hc = fi->facet_begin();
HFC hc_end = hc;
Polyhedron::Vertex_handle vf1 = (*hc).vertex();
hc++;
Polyhedron::Vertex_handle vf2 = (*hc).vertex();
hc++;
Polyhedron::Vertex_handle vf3 = (*hc).vertex();
hc++;
K::Point_3 pf1 = vf1->point();
K::Point_3 pf2 = vf2->point();
K::Point_3 pf3 = vf3->point();
Vettore v1(pf1.x(),pf1.y(),pf1.z());
Vettore v2(pf2.x(),pf2.y(),pf2.z());
Vettore v3(pf3.x(),pf3.y(),pf3.z());
Vettore vN(3);
v1.Mult(InvScaleUn);
v2.Mult(InvScaleUn);
v3.Mult(InvScaleUn);
vN = (v1-v2) ^ (v3-v2);
//if(vN.Norm() > 2.*AreaMean) continue;
double Sfumatura = .3*Mat->Casuale();
glColor4f(0.1,.4+Sfumatura,0.2,1.);
//glColor4f(HueUp[p].r,HueUp[p].g,HueUp[p].b,HueUp[p].a);
DrTria(&v1,&v2,&v3,&vN);
glColor4f(1.,.0,0.,1.);
DrTriaContour(&v1,&v2,&v3);
// glPushMatrix();//Particle
// glBegin(GL_LINES);
// do {
// Polyhedron::Vertex_handle vh = (*hc).vertex();
// K::Point_3 pf1 = vh->point();
// glVertex3d(pf1.x(),pf1.y(),pf1.z());
// } while (++hc != hc_end);
// glEnd();
// glPopMatrix();//Particle
}
glEndList();
// Tr tr; // 3D-Delaunay triangulation
// C2t3 c2t3 (tr); // 2D-complex in 3D-Delaunay triangulation
// Surface_3 surface(sphere_function,Sphere_3(CGAL::ORIGIN, 2.));
// Surface_mesh_default_criteria_3<Tr> criteria(30., 0.1,0.1);
// // meshing surface
// make_surface_mesh(c2t3, surface, criteria, CGAL::Non_manifold_tag());
// std::cout << "Final number of points: " << tr.number_of_vertices() << "\n";
// DT dt;
// for(int c=0;c<Gen->NChain;c++){
// if(CHAIN_IF_TYPE(Ch[c].Type,CHAIN_UP) )continue;
// Point_3<K> ChPos(pPos(c,CLat1),pPos(c,CLat2),pPos(c,CNorm));
// dt.insert(ChPos);
// }
// Face_iterator fcTr = dt.finite_faces_begin();
// glDeleteLists(Dr->Particles,1);
// Dr->Particles = glGenLists(1);
// glNewList(Dr->Particles,GL_COMPILE);
// for(;fcTr != dt.faces_end(); ++fcTr){
// Vertex_handle vf1 = fcTr->vertex(0),
// vf2 = fcTr->vertex(1),vf3 = fcTr->vertex(2);
// Point pf1 = vf1->point();
// Point pf2 = vf2->point();
// Point pf3 = vf3->point();
// Vettore v1(pf1.x() - pf2.x(),pf1.y() - pf2.y(),pf1.z()-pf2.z());
// Vettore v2(pf3.x() - pf2.x(),pf3.y() - pf2.y(),pf1.z()-pf2.z());
// Vettore vN(3);
// vN = v1 ^ v2;
// DrTira(v1,v2,v3,vN);
// }
// glEndList();
}
int main(int argc, char * argv[])
{
std::cerr << "PARAMETERIZATION" << std::endl;
std::cerr << " Floater parameterization" << std::endl;
std::cerr << " Circle border" << std::endl;
std::cerr << " OpenNL solver" << std::endl;
std::cerr << " Very simple cut if model is not a topological disk" << std::endl;
//***************************************
// decode parameters
//***************************************
if (argc-1 != 1)
{
std::cerr << "Usage: " << argv[0] << " input_file.off" << std::endl;
return(EXIT_FAILURE);
}
// File name is:
const char* input_filename = argv[1];
//***************************************
// Read the mesh
//***************************************
// Read the mesh
std::ifstream stream(input_filename);
Polyhedron mesh;
stream >> mesh;
if(!stream || !mesh.is_valid() || mesh.empty())
{
std::cerr << "Error: cannot read OFF file " << input_filename << std::endl;
return EXIT_FAILURE;
}
//***************************************
// Create Polyhedron adaptor
//***************************************
Parameterization_polyhedron_adaptor mesh_adaptor(mesh);
//***************************************
// Virtually cut mesh
//***************************************
// The parameterization methods support only meshes that
// are topological disks => we need to compute a "cutting" of the mesh
// that makes it homeomorphic to a disk
Seam seam = cut_mesh(mesh_adaptor);
if (seam.empty())
{
std::cerr << "Input mesh not supported: the example cutting algorithm is too simple to cut this shape" << std::endl;
return EXIT_FAILURE;
}
// Create a second adaptor that virtually "cuts" the mesh following the 'seam' path
typedef CGAL::Parameterization_mesh_patch_3<Parameterization_polyhedron_adaptor>
Mesh_patch_polyhedron;
Mesh_patch_polyhedron mesh_patch(mesh_adaptor, seam.begin(), seam.end());
if (!mesh_patch.is_valid())
{
std::cerr << "Input mesh not supported: non manifold shape or invalid cutting" << std::endl;
return EXIT_FAILURE;
}
//***************************************
// Floater Mean Value Coordinates parameterization
//***************************************
typedef CGAL::Parameterizer_traits_3<Mesh_patch_polyhedron>
Parameterizer; // Type that defines the error codes
Parameterizer::Error_code err = CGAL::parameterize(mesh_patch);
switch(err) {
case Parameterizer::OK: // Success
break;
case Parameterizer::ERROR_EMPTY_MESH: // Input mesh not supported
case Parameterizer::ERROR_NON_TRIANGULAR_MESH:
case Parameterizer::ERROR_NO_TOPOLOGICAL_DISC:
case Parameterizer::ERROR_BORDER_TOO_SHORT:
std::cerr << "Input mesh not supported: " << Parameterizer::get_error_message(err) << std::endl;
return EXIT_FAILURE;
break;
default: // Error
std::cerr << "Error: " << Parameterizer::get_error_message(err) << std::endl;
return EXIT_FAILURE;
break;
};
//***************************************
// Output
//***************************************
// Raw output: dump (u,v) pairs
Polyhedron::Vertex_const_iterator pVertex;
for (pVertex = mesh.vertices_begin();
pVertex != mesh.vertices_end();
pVertex++)
{
// (u,v) pair is stored in any halfedge
double u = mesh_adaptor.info(pVertex->halfedge())->uv().x();
double v = mesh_adaptor.info(pVertex->halfedge())->uv().y();
std::cout << "(u,v) = (" << u << "," << v << ")" << std::endl;
}
return EXIT_SUCCESS;
}
/*
* mexFunction(): entry point for the mex function
*/
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]) {
// interface to deal with input arguments from Matlab
enum InputIndexType {IN_TRI, IN_X, IN_METHOD, IN_ITER, InputIndexType_MAX};
MatlabImportFilter::Pointer matlabImport = MatlabImportFilter::New();
matlabImport->ConnectToMatlabFunctionInput(nrhs, prhs);
// check that we have all input arguments
matlabImport->CheckNumberOfArguments(2, InputIndexType_MAX);
// register the inputs for this function at the import filter
MatlabInputPointer inTRI = matlabImport->RegisterInput(IN_TRI, "TRI");
MatlabInputPointer inX = matlabImport->RegisterInput(IN_X, "X");
MatlabInputPointer inMETHOD = matlabImport->RegisterInput(IN_METHOD, "METHOD");
MatlabInputPointer inITER = matlabImport->RegisterInput(IN_ITER, "ITER");
// interface to deal with outputs to Matlab
enum OutputIndexType {OUT_TRI, OUT_N, OutputIndexType_MAX};
MatlabExportFilter::Pointer matlabExport = MatlabExportFilter::New();
matlabExport->ConnectToMatlabFunctionOutput(nlhs, plhs);
// check number of outputs the user is asking for
matlabExport->CheckNumberOfArguments(0, OutputIndexType_MAX);
// register the outputs for this function at the export filter
typedef MatlabExportFilter::MatlabOutputPointer MatlabOutputPointer;
MatlabOutputPointer outTRI = matlabExport->RegisterOutput(OUT_TRI, "TRI");
MatlabOutputPointer outN = matlabExport->RegisterOutput(OUT_N, "N");
// if any of the inputs is empty, the output is empty too
if (mxIsEmpty(prhs[IN_TRI]) || mxIsEmpty(prhs[IN_X])) {
matlabExport->CopyEmptyArrayToMatlab(outTRI);
matlabExport->CopyEmptyArrayToMatlab(outN);
return;
}
// polyhedron to contain the input mesh
Polyhedron mesh;
PolyhedronBuilder<Polyhedron> builder(matlabImport, inTRI, inX);
mesh.delegate(builder);
// get size of input matrix with the points
mwSize nrowsTri = mxGetM(inTRI->pm);
mwSize nrowsX = mxGetM(inX->pm);
#ifdef DEBUG
std::cout << "Number of facets read = " << mesh.size_of_facets() << std::endl;
std::cout << "Number of vertices read = " << mesh.size_of_vertices() << std::endl;
#endif
if (nrowsTri != mesh.size_of_facets()) {
mexErrMsgTxt(("Input " + inTRI->name + ": Number of triangles read into mesh different from triangles provided at the input").c_str());
}
if (nrowsX != mesh.size_of_vertices()) {
mexErrMsgTxt(("Input " + inX->name + ": Number of vertices read into mesh different from vertices provided at the input").c_str());
}
// sort halfedges such that the non-border edges precede the
// border edges. We need to do this before any halfedge iterator
// operations are valid
mesh.normalize_border();
#ifdef DEBUG
std::cout << "Number of border halfedges = " << mesh.size_of_border_halfedges() << std::endl;
#endif
// number of holes we have filled
mwIndex n = 0;
// a closed mesh with no holes will have no border edges. What we do
// is grab a border halfedge and close the associated hole. This
// makes the rest of the iterators invalid, so we have to normalize
// the mesh again. Then we iterate, looking for a new border
// halfedge, filling the hole, etc.
//
// Note that confusingly, mesh.border_halfedges_begin() gives a
// pointer to the halfedge that is NOT a border in a border
// edge. The border halfedge is instead
// mesh.border_halfedges_begin()->opposite()
while (!mesh.is_closed()) {
// exit if user pressed Ctrl+C
ctrlcCheckPoint(__FILE__, __LINE__);
// get the first hole we can find, and close it
mesh.fill_hole(mesh.border_halfedges_begin()->opposite());
// increase the counter of number of holes we have filled
n++;
// renormalize mesh so that halfedge iterators are again valid
mesh.normalize_border();
}
// split all facets to triangles
CGAL::triangulate_polyhedron<Polyhedron>(mesh);
// copy output with number of holes filled
std::vector<double> nout(1, n);
matlabExport->CopyVectorOfScalarsToMatlab<double, std::vector<double> >(outN, nout, 1);
// allocate memory for Matlab outputs
double *tri = matlabExport->AllocateMatrixInMatlab<double>(outTRI, mesh.size_of_facets(), 3);
// extract the triangles of the solution
// snippet adapted from CgalMeshSegmentation.cpp
// vertices coordinates. Assign indices to the vertices by defining
// a map between their handles and the index
std::map<Vertex_handle, int> V;
int inum = 0;
for(Vertex_iterator vit = mesh.vertices_begin(); vit != mesh.vertices_end(); ++vit) {
// save to internal list of vertices
V[vit] = inum++;
}
// triangles given as (i,j,k), where each index corresponds to a vertex in x
mwIndex row = 0;
for (Facet_iterator fit = mesh.facets_begin(); fit != mesh.facets_end(); ++fit, ++row) {
if (fit->facet_degree() != 3) {
std::cerr << "Facet has " << fit->facet_degree() << " edges" << std::endl;
mexErrMsgTxt("Facet does not have 3 edges");
}
// go around the half-edges of the facet, to extract the vertices
Halfedge_around_facet_circulator heit = fit->facet_begin();
int idx = 0;
do {
// extract triangle indices and save to Matlab output
// note that Matlab indices go like 1, 2, 3..., while C++ indices go like 0, 1, 2...
tri[row + idx * mesh.size_of_facets()] = 1 + V[heit->vertex()];
idx++;
} while (++heit != fit->facet_begin());
}
}
void Polyhedron_demo_jet_fitting_plugin::on_actionEstimateCurvature_triggered()
{
// get active polyhedron
const Scene_interface::Item_id index = scene->mainSelectionIndex();
Scene_polyhedron_item* poly_item =
qobject_cast<Scene_polyhedron_item*>(scene->item(index));
if(!poly_item)
return;
// wait cursor
QApplication::setOverrideCursor(Qt::WaitCursor);
Polyhedron* pMesh = poly_item->polyhedron();
// types
typedef CGAL::Monge_via_jet_fitting<Kernel> Fitting;
typedef Fitting::Monge_form Monge_form;
typedef Kernel::Point_3 Point;
Scene_polylines_item* max_curv = new Scene_polylines_item;
max_curv->setColor(Qt::red);
max_curv->setName(tr("%1 (max curvatures)").arg(poly_item->name()));
Scene_polylines_item* min_curv = new Scene_polylines_item;
min_curv->setColor(Qt::green);
min_curv->setName(tr("%1 (min curvatures)").arg(poly_item->name()));
Polyhedron::Vertex_iterator v;
for(v = pMesh->vertices_begin();
v != pMesh->vertices_end();
v++)
{
std::vector<Point> points;
// pick central point
const Point& central_point = v->point();
points.push_back(central_point);
// compute min edge len around central vertex
// to scale the ribbons used to display the directions
typedef Kernel::FT FT;
FT min_edge_len = std::numeric_limits<FT>::infinity();
Polyhedron::Halfedge_around_vertex_circulator he = v->vertex_begin();
Polyhedron::Halfedge_around_vertex_circulator end = he;
CGAL_For_all(he,end)
{
const Point& p = he->opposite()->vertex()->point();
points.push_back(p);
FT edge_len = std::sqrt(CGAL::squared_distance(central_point,p));
min_edge_len = edge_len < min_edge_len ? edge_len : min_edge_len; // avoids #undef min
}
if(points.size() > 5)
{
// estimate curvature by fitting
Fitting monge_fit;
const int dim_monge = 2;
const int dim_fitting = 2;
Monge_form monge_form = monge_fit(points.begin(),points.end(),dim_fitting,dim_monge);
// make monge form comply with vertex normal (to get correct
// orientation)
typedef Kernel::Vector_3 Vector;
Vector n = CGAL::Polygon_mesh_processing::compute_vertex_normal(v, *pMesh);
monge_form.comply_wrt_given_normal(n);
Vector umin = min_edge_len * monge_form.minimal_principal_direction();
Vector umax = min_edge_len * monge_form.maximal_principal_direction();
Scene_polylines_item::Polyline max_segment(2), min_segment(2);
const double du = 0.2;
max_segment[0] = central_point + du * umax;
max_segment[1] = central_point - du * umax;
min_segment[0] = central_point + du * umin;
min_segment[1] = central_point - du * umin;
max_curv->polylines.push_back(max_segment);
min_curv->polylines.push_back(min_segment);
}
}
scene->addItem(max_curv);
scene->addItem(min_curv);
max_curv->changed();
min_curv->changed();
// default cursor
QApplication::restoreOverrideCursor();
}
void PoissonSurfaceReconstruction::reconstruct(std::vector<Eigen::Vector3d> &points, std::vector<Eigen::Vector3d> &normals, TriangleMesh &mesh){
assert(points.size() == normals.size());
std::cout << "creating points with normal..." << std::endl;
std::vector<Point_with_normal> points_with_normal;
points_with_normal.resize((int)points.size());
for(int i=0; i<(int)points.size(); i++){
Vector vec(normals[i][0], normals[i][1], normals[i][2]);
//Point_with_normal pwn(points[i][0], points[i][1], points[i][2], vec);
//points_with_normal[i] = pwn;
points_with_normal[i] = Point_with_normal(points[i][0], points[i][1], points[i][2], vec);
}
std::cout << "constructing poisson reconstruction function..." << std::endl;
Poisson_reconstruction_function function(points_with_normal.begin(), points_with_normal.end(),
CGAL::make_normal_of_point_with_normal_pmap(PointList::value_type()));
std::cout << "computing implicit function..." << std::endl;
if( ! function.compute_implicit_function() ) {
std::cout << "compute implicit function is failure" << std::endl;
return;
}
//return EXIT_FAILURE;
// Computes average spacing
std::cout << "compute average spacing..." << std::endl;
FT average_spacing = CGAL::compute_average_spacing(points_with_normal.begin(), points_with_normal.end(),
6 /* knn = 1 ring */);
// Gets one point inside the implicit surface
// and computes implicit function bounding sphere radius.
Point inner_point = function.get_inner_point();
Sphere bsphere = function.bounding_sphere();
FT radius = std::sqrt(bsphere.squared_radius());
// Defines the implicit surface: requires defining a
// conservative bounding sphere centered at inner point.
FT sm_sphere_radius = 5.0 * radius;
FT sm_dichotomy_error = distance_criteria*average_spacing/1000.0; // Dichotomy error must be << sm_distance
//FT sm_dichotomy_error = distance_criteria*average_spacing/10.0; // Dichotomy error must be << sm_distance
std::cout << "reconstructed surface" << std::endl;
Surface_3 reconstructed_surface(function,
Sphere(inner_point,sm_sphere_radius*sm_sphere_radius),
sm_dichotomy_error/sm_sphere_radius);
// Defines surface mesh generation criteria
CGAL::Surface_mesh_default_criteria_3<STr> criteria(angle_criteria, // Min triangle angle (degrees)
radius_criteria*average_spacing, // Max triangle size
distance_criteria*average_spacing); // Approximation error
std::cout << "generating surface mesh..." << std::endl;
// Generates surface mesh with manifold option
STr tr; // 3D Delaunay triangulation for surface mesh generation
C2t3 c2t3(tr); // 2D complex in 3D Delaunay triangulation
CGAL::make_surface_mesh(c2t3, // reconstructed mesh
reconstructed_surface, // implicit surface
criteria, // meshing criteria
CGAL::Manifold_tag()); // require manifold mesh
if(tr.number_of_vertices() == 0){
std::cout << "surface mesh generation is failed" << std::endl;
return;
}
Polyhedron surface;
CGAL::output_surface_facets_to_polyhedron(c2t3, surface);
// convert CGAL::surface to TriangleMesh //
std::cout << "converting CGA::surface to TriangleMesh..." << std::endl;
std::vector<Eigen::Vector3d> pts;
std::vector<std::vector<int> > faces;
pts.resize(surface.size_of_vertices());
faces.resize(surface.size_of_facets());
Polyhedron::Point_iterator pit;
int index = 0;
for(pit=surface.points_begin(); pit!=surface.points_end(); ++pit){
pts[index][0] = pit->x();
pts[index][1] = pit->y();
pts[index][2] = pit->z();
index ++;
}
index = 0;
Polyhedron::Face_iterator fit;
for(fit=surface.facets_begin(); fit!=surface.facets_end(); ++fit){
std::vector<int > face(3);
Halfedge_facet_circulator j = fit->facet_begin();
int f_index = 0;
do {
face[f_index] = std::distance(surface.vertices_begin(), j->vertex());
f_index++;
} while ( ++j != fit->facet_begin());
faces[index] = face;
index++;
}
mesh.createFromFaceVertex(pts, faces);
}
int main() {
//std::cout<<CGBench::BendBench::Run(CGBench::VMag::M1)<<std::endl;
//CGBench::BenchLanuch(CGBench::VMag::M3,CGBench::VMag::M3);
/*std::ofstream of("C:\\123.off");
std::vector <Point_3> arr;
arr.push_back(Point_3 (2,0,2));
arr.push_back(Point_3 (6,0,3));
arr.push_back(Point_3 (8,0,4));
arr.push_back(Point_3 (3,0,5));
arr.push_back(Point_3 (5,0,6));
arr.push_back(Point_3 (8,0,7));
arr.push_back(Point_3 (0,1.75,8));
arr.push_back(Point_3 (0,1.50,8));
arr.push_back(Point_3 (0,1.25,8));
arr.push_back(Point_3 (0,1,8));
arr.push_back(Point_3 (0,1,7));
arr.push_back(Point_3 (0,1,6));
arr.push_back(Point_3 (0,1,5));
arr.push_back(Point_3 (0,1,4));
arr.push_back(Point_3 (0,1,3));
arr.push_back(Point_3 (0,1.25,3));
arr.push_back(Point_3 (0,1.50,3));
arr.push_back(Point_3 (0,1.75,3));
Point_3* Center = new Point_3(0,0,0);*/
//Arc_2 s(30,270,30,true);
//Circle_2 s(4,20);
//Ellipse_2 s(6,4,30);
//Plane_3 s(30,30,10,10);
//Rectangle_2 s(20,10);
//Box_3 s(20,20,20,15,15,15);
//Capsule_3 s(30,200,10,10);
//ChamferCyl_3 s(60,100,30,10,5,5,15);
//Cone_3 s(2,5,10,3,3,3);
//Cylinder_3 s(3,20,20,9,30);
//Lathe_3 s(arr,Center,Z_ax,20,360);
//Pyramid_3 s(100,200,200,4,4,4);
//Sphere_3 s(20,50);
//Spindle_3 s(10,30,20,10,5,15);
//Spring_3 s(20,2.5,200,10,10,40);
//Torus_3 s(20,5,0,0,30,40);
//Tube_3 s(14,13,15,20,20,10);
//Polyhedron P;
//P = s.Draw();
//Traingulate trg;
//P=s.Draw();
//std::transform(P.facets_begin(), P.facets_end(), P.planes_begin(), Normal_vector());
/*Eigen::Transform3d T;
Eigen::Vector3d Original(0,0,10);
T.setIdentity();
T.pretranslate (-Original);
trg.ApplyTransformToPolyhedron(P,T);*/
//Traingulate tr;
//tr.Do(P);
//Bevel Be(400,-4,1.25);
//Be.Do(P);
//Bridge Br(18,20);
//Br.Do(P);
//Extrude Ex(45,15);
//Ex.Do(P);
//Outline Ou(45,1.5);
//Ou.Do(P);
//Bend Ben(90,s.Center,Y_ax,false,20,-20);
//Ben.Do(P);
//Bulge Bu(40,s.Center,Z_ax,BRadial,false,45,-45);
//Bu.Do(P);
//Cylindrical_Wave CylWa(2,8,12,s.Center,Z_ax);
//CylWa.Do(P);
//Linear_Wave LiWaX(1,10,0,s.Center,Z_ax,X_ax);
//LiWaX.Do(P);
//Linear_Wave LiWaY(2,10,0,s.Center,Z_ax,Y_ax);
//LiWaY.Do(P);
/*ChamferCyl_3 n(1,50,5,10,10,10,40);
Spindle_3 p(5,30,5,10,20,40);
Polyhedron P;
Polyhedron E;
E = p.Draw();
P = n.Draw();
Morph Mor(E,50);
Mor.Do(P);*/
//Noise No(5,0.3,0,s.Center,Z_ax);
//No.Do(P);
//Skew Sk(30,s.Center,Z_ax,false,20,-20);
//Sk.Do(P);
//Smooth Sm(1);
//Sm.Do(P);
//Spherify Sph(50);
//Sph.Do(P);
//Squeeze Sq(-30,s.Center,Z_ax,false,10,0);
//Sq.Do(P);
//Stretch St(-20,s.Center,Z_ax,true,50,-50);
//St.Do(P);
//Taper Ta(3,s.Center,X_ax,false,20,-20);
//Ta.Do(P);
//Twist Tw(270,s.Center,Z_ax,true,-5,15);
//Tw.Do(P);
/*Box_3 B(20, 30, 60, 20, 30, 30);
Polyhedron P = B.Draw();
Twist Tw1(270, B.Center, Z_ax, true, 30, 10);
Twist Tw2(-270, B.Center, Z_ax, true, -10, -30);
Stretch St(30, B.Center, Z_ax, true, 20,-20);
Squeeze Sq(15, B.Center, Z_ax);
Tw1.Do(P);
Tw2.Do(P);
Sq.Do(P);
St.Do(P);*/
std::ofstream of("C:\\123.off");
Box_3 B(20, 30, 60, 20, 30, 30);
Polyhedron P = B.Draw();
Twist Tw1(270, B.Center, Z_ax, true, 30, 10);
Twist Tw2(-270, B.Center, Z_ax, true, -10, -30);
Stretch St(30, B.Center, Z_ax, true, 20,-20);
Squeeze Sq(15, B.Center, Z_ax);
Tw1.Do(P);
Tw2.Do(P);
Sq.Do(P);
St.Do(P);
//// Write polyhedron in Object File Format (OFF).
CGAL::set_ascii_mode( of );
of << "OFF" << std::endl << P.size_of_vertices() << ' ' << P.size_of_facets() << " 0" << std::endl;
std::copy( P.points_begin(), P.points_end(), std::ostream_iterator<Point_3>( of, "\n"));
for ( Facet_iterator i = P.facets_begin(); i != P.facets_end(); ++i)
{
Halfedge_facet_circulator j = i->facet_begin();
// Facets in polyhedral surfaces are at least triangles.
CGAL_assertion( CGAL::circulator_size(j) >= 3);
of << CGAL::circulator_size(j) << ' ';
do
{
of << ' ' << std::distance(P.vertices_begin(), j->vertex());
} while ( ++j != i->facet_begin());
of << std::endl;
}
/* Write polyhedron in (OBJ).
CGAL::set_ascii_mode( oof );
oof << "# " << P.size_of_vertices() << ' ' << std::endl <<"# "<< P.size_of_facets() << std::endl;
oof<<"v ";
std::copy( P.points_begin(), P.points_end(), std::ostream_iterator<Point_3>( oof, "\nv "));
oof<<"_ _ _\n";
for ( Facet_iterator i = P.facets_begin(); i != P.facets_end(); ++i)
{
Halfedge_facet_circulator j = i->facet_begin();
// Facets in polyhedral surfaces are at least triangles.
//CGAL_assertion( CGAL::circulator_size(j) >= 3);
oof << 'f' << ' ';
do
{
oof << ' ' << std::distance(P.vertices_begin(), j->vertex())+1;
} while ( ++j != i->facet_begin());
oof << std::endl;
}
*/
return 0;
}
// a helper method for running different iterators
void running_iterators( Polyhedron& P) {
if ( P.size_of_facets() == 0)
return;
std::size_t nv = P.size_of_vertices();
std::cout << "The number of vertices in the Polyhedron: " << nv << std::endl;
std::cout << "The number of facets in the Polyhedron: " << P.size_of_facets() << std::endl;
std::cout << "The number of half edges in the Polyhedron: " << P.size_of_halfedges() << std::endl;
std::cout << std:: endl;
Polyhedron::Vertex_iterator last_v = P.vertices_end();
-- last_v; // the last of the old vertices
Polyhedron::Edge_iterator last_e = P.edges_end();
-- last_e; // the last of the old edges
Polyhedron::Facet_iterator last_f = P.facets_end();
-- last_f; // the last of the old facets
int k = 0;
Polyhedron::Facet_iterator f = P.facets_begin();
do {
std::cout << "Printing a facet index: " << k++ << std::endl;
f->halfedge();
} while ( f++ != last_f);
std::cout << std::endl;
// -------------------------------------------------
// traverse the vertices
// -------------------------------------------------
std::cout << "Printing the vertex indices: " << std::endl;
int n=0;
for (Polyhedron::Vertex_iterator vi = P.vertices_begin(); vi != P.vertices_end(); ++vi)
{
Kernel::Point_3 p;
p = vi->point();
std::cout << "Vertex index: " << n++ << std::endl;
std::cout << "p.x() = " << p.x() << std::endl;
std::cout << "p.y() = " << p.y() << std::endl;
std::cout << "p.z() = " << p.z() << std::endl;
}
std::cout << std::endl;
// -------------------------------------------------
// traverse the edges
// -------------------------------------------------
std::cout << "Iterating over the edges.... " << std::endl;
n=0;
for (Polyhedron::Edge_iterator ei = P.edges_begin(); ei != P.edges_end(); ++ei)
{
ei->next();
Kernel::Point_3 p;
p = ei->vertex()->point();
std::cout << "For edge index: " << n++ << std::endl;
std::cout << "p.x() = " << p.x() << std::endl;
std::cout << "p.y() = " << p.y() << std::endl;
std::cout << "p.z() = " << p.z() << std::endl;
}
std::cout << std::endl;
// -----------------------------------------------
// Do something else with the edge iterators
// -----------------------------------------------
Polyhedron::Edge_iterator e = P.edges_begin();
++ last_e; // make it the past-the-end position again
while ( e != last_e) {
Polyhedron::Halfedge_handle h = e;
++e;
};
CGAL_postcondition( P.is_valid());
}
