ENH: compute_RVD geogram example, add facets region when using `RVD_cells=true` and exporting mesh to `*.eobj`

[antoinecollet5]

Hi,

I have been playing around a bit with the compute_RVD geogram example program.

Here is a little dataset that I use for the tests, a point cloud for seeds and a triangulated closed manifold surface enclosing all points:

res_vol_mesh_triangles.txt

cloud.txt

You will have to rename from .txt to .obj.

It works great and I even added some options in #336 to obtain something like this:

compute_RVD res_vol_mesh_triangles.obj cloud.obj test_voro_cells.eobj algo:predicates=exact RVD_cells=true RVD_cells:simplify_boundary=true RVD_cells:simplify_boundary_angle_threshold=1.0

However, I noticed that when using RVD_cells=true, cells are not computed at all (only vertices and facets). It is then impossible to link faces to seeds without post-processing the .obj file. That would be a great feature to add.

I am really new to geogram so I am a bit confused for now. I started to play a bit with the class SaveRVDCells but I am not so sure how to create correctly the cells. Looking at the mechanic for the faces - created when calling end_facet() - I guess cells would need to be created when calling end_polyhedron(), itself called by RVDPolyhedronCallback::process_polyhedron_mesh().
And probably something like this is needed later on:

                if(M.facets.nb() != 0) {
                    Attribute<index_t> facet_region_attr(
                        M.facets.attributes(), "region"
                    );
                    for(index_t f=0; f<M.facets.nb(); ++f) {
                        facet_region_attr[f] = facet_regions[f];
                    }
                }

So that the region (seed) for each facet is correctly exported to the .eobj file.

Am I correct @BrunoLevy .

Thank in advance for the help.

Antoine

[antoinecollet5]

After a few trials, I came up with something like:

        void end_facet() override {
            // Create the facet from the memorized indices.
            index_t f = output_mesh_.facets.nb();
            output_mesh_.facets.create_polygon(current_facet_.size());
            for(index_t i=0; i<current_facet_.size(); ++i) {
                output_mesh_.facets.set_vertex(f,i,current_facet_[i]);
            }
            // link the facet to its seed
            facet_regions_.push_back(current_seed_id_);
        }

        void end_polyhedron() override {
            // Nothing to do.
            // update the number of polyhedron (1 poly = 1 seed) created
            current_seed_id_ += 1;
        }

        void process_polyhedron_mesh() override {
            // This function is called for each cell if set_use_mesh(true) was called.
            // It is the case if simplify_voronoi_facets(true) or
            // simplify_boundary_facets(true) was called.
            //   Note1: most users will not need to overload this function (advanded use
            //   only).
            //   Note2: mesh_ is managed internally by RVDPolyhedronCallback class, as an
            // intermediary representation to store the cell before calling the callbacks.
            // It is distinct from the output_mesh_ constructed by the callbacks.

            //   The current cell represented by a Mesh can be
            // filtered/modified/post-processed (member variable mesh_)
            // here, before calling base class's implementation.
            //   As an example, we shrink the cells. More drastic modifications/
            // transformations of the mesh can be done (see base class's implementation
            // in geogram/voronoi/RVD_polyhedron_callback.cpp).
            double shrink = CmdLine::get_arg_double("RVD_cells:shrink");
            if(shrink != 0.0 && mesh_.vertices.nb() != 0) {
                vec3 center(0.0, 0.0, 0.0);
                for(index_t v=0; v<mesh_.vertices.nb(); ++v) {
                    center += vec3(mesh_.vertices.point_ptr(v));
                }
                center = (1.0 / double(mesh_.vertices.nb())) * center;
                for(index_t v=0; v<mesh_.vertices.nb(); ++v) {
                    vec3 p(mesh_.vertices.point_ptr(v));
                    p = shrink * center + (1.0 - shrink) * p;
                    mesh_.vertices.point_ptr(v)[0] = p.x;
                    mesh_.vertices.point_ptr(v)[1] = p.y;
                    mesh_.vertices.point_ptr(v)[2] = p.z;
                }
            }

            //  The default implementation simplifies Voronoi facets
            // and boundary mesh facets based on the boolean flags
            // defined by set_simplify_xxx(). Then it calls the callbacks
            // for each mesh facet.
            RVDPolyhedronCallback::process_polyhedron_mesh();

        }

        // Getter for the region associated with each facet
        index_t get_facet_region(const index_t facet_id) const {
            return facet_regions_[facet_id];
        }

    private:
        // Keep track of the voronoi seed
        index_t current_seed_id_ {0};
        // Vector storing the seed associated with each facet
        vector<index_t> facet_regions_{};
        vector<index_t> current_facet_;
        Mesh& output_mesh_;
        RVDVertexMap* my_vertex_map_;
    };

    void compute_RVD_cells(RestrictedVoronoiDiagram* RVD, Mesh& RVD_mesh) {
        SaveRVDCells callback(RVD_mesh);
        RVD->for_each_polyhedron(callback, true, true, CmdLine::get_arg_bool("RVD_cells:parallel"));
        // Link facets to seeds
        if(RVD_mesh.facets.nb() != 0) {
            Attribute<index_t> facet_region_attr(
                RVD_mesh.facets.attributes(), "region"
            );
            for(index_t f=0; f<RVD_mesh.facets.nb(); ++f) {
                facet_region_attr[f] = callback.get_facet_region(f);
            }
        }
    }

And it seems to do the job (at least with a single thread).

RVD->for_each_polyhedron(callback, true, true, CmdLine::get_arg_bool("RVD_cells:parallel"));

was modified in #336 .

Maybe there is a cleaner way ? Are you interested by a PR ? Rework that a bit ?