CGAL users discussion list

[Iasonm <>]

I am trying to make the following code faster. Initializing the size of
points and faces would make the code faster but is there a way to know the
number of unique vertices of a segment without traversing its faces? Any
other ideas are welcomed..

        const auto &segmentMap = m_segmentFaceMap; //the output of the sdf
segmentation algorithm
        std::vector<Kernel::Point_3> points;
        std::vector<std::vector&lt;size_t>> faces;
        for (CGALSurfaceMesh::Face_iterator it = M.faces_begin();
             it != M.faces_end(); it++) {
                CGALSurfaceMesh::Face_index fIndex(*it);
                if (segmentMap[fIndex] == segmentIndex) {
                        CGALSurfaceMesh::Halfedge_index h =
M.halfedge(fIndex);

                        CGALSurfaceMesh::Vertex_index v1;  //= M.source(h);
                        CGALSurfaceMesh::Vertex_index v2;  //= M.target(h);
                        CGALSurfaceMesh::Vertex_index v3;  //=
M.target(hNext);

                        auto vri = M.vertices_around_face(h);
                        v1 = *vri.begin();
                        v2 = *(++vri.begin());
                        v3 = *(++++vri.begin());

                        CGALSurfaceMesh::Point p1(M.point(v1));
                        CGALSurfaceMesh::Point p2(M.point(v2));
                        CGALSurfaceMesh::Point p3(M.point(v3));

                        size_t i1 = std::distance(
                            points.begin(),
                            std::find(points.begin(), points.end(), p1));
//find index of p1
                        if (i1 == points.size()) { //if p1 does not exist in
points add it and update its index
                                points.push_back(p1);
                                i1 = points.size() - 1;
                        }

                        size_t i2 = std::distance(  
                            points.begin(),
                            std::find(points.begin(), points.end(), p2));
//same as p1
                        if (i2 == points.size()) {
                                points.push_back(p2);
                                i2 = points.size() - 1;
                        }

                        size_t i3 = std::distance(
                            points.begin(),
                            std::find(points.begin(), points.end(), p3));
//same as p1
                        if (i3 == points.size()) {
                                points.push_back(p3);
                                i3 = points.size() - 1;
                        }

                        std::vector<size_t> face{i1, i2, i3};
                        faces.push_back(face);
                }
        }
        CGALSurfaceMesh outputMesh;
        CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh(
            points, faces, outputMesh);
        return outputMesh;




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