CGAL users discussion list

[sergio <>]

Hello,

This is my implementation and checking with the file
cube_nonmanifold_vertex.off

OFF
10 13 0
-1 -1 -1
-1 1 -1
1 1 -1
1 -1 -1
-1 -1 1
-1 1 1
1 1 1
1 -1 1
*2 2 2
2 2 1*
3  0 1 3
3  3 1 2
3  0 4 1
3  1 4 5
3  3 2 7
3  7 2 6
3  4 0 3
3  7 4 3
3  6 4 7
3  6 5 4
3  1 5 6
3  2 1 6
*3  6 8 9*

we can check that after mesh is pass for polygon_soup_to_polygon_mesh the
non-manifold is remove. What I want to do is to detect the non manifold
vertex. What wrong?



#include <CGAL/Surface_mesh.h>
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>

#include <iostream>
#include <fstream>
#include <list>

#include <CGAL/IO/OFF_reader.h>
#include <CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h>


typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::Point_3                                      Point;
typedef CGAL::Surface_mesh<Point>                            Mesh;
typedef Mesh::Face_index face_descriptor;
typedef typename Mesh::halfedge_index halfedge_descriptor;

bool getMeshFromPolygonSoup(const char* filename, Mesh &mesh)
{
        std::ifstream input(filename);
        if (!input)
        {
                std::cerr << "Cannot open file " << std::endl;
                return false;
        }
        std::vector<Point> points;
        std::vector< std::vector<std::size_t> > polygons;
        if (!CGAL::read_OFF(input, points, polygons))
        {
                std::cerr << "Error parsing the OFF file " << std::endl;
                return false;
        }
        CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh(points,
polygons, mesh);
        return true;
}

void check_manifold_vertex(const Mesh& mesh)
{
        std::set<face_descriptor> faces_;
        BOOST_FOREACH(face_descriptor fd, faces(mesh)) {
                // ids are between [0, number_of_segments -1]
                faces_.insert(fd);
        }


        std::vector<halfedge_descriptor> boundary_hedges;

        BOOST_FOREACH(face_descriptor fh, faces_)
        {
                std::cout << "halfedge" << std::endl;
                halfedge_descriptor h = halfedge(fh, mesh);
                for (int i = 0; i < 3; ++i)
                {
                        std::cout << "vertex" <<i<< std::endl;
                        if (is_border(opposite(h, mesh), mesh) || 
faces_.count(face(opposite(h,
mesh), mesh)) == 0)
                        {
                                std::cout << "boundary edge" << std::endl;
                                boundary_hedges.push_back(h);

                        }
                        h = next(h, mesh);
                }

        }
}

int main(int, char** argv) 
{
        Mesh sm;
        getMeshFromPolygonSoup(argv[1], sm);
        check_manifold_vertex(sm);

        
        return 0;
}



--
Sent from: http://cgal-discuss.949826.n4.nabble.com/