renderer.h

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#ifndef EASY3D_RENDERER_RENDERER_H
#define EASY3D_RENDERER_RENDERER_H
 
#include <string>
#include <vector>
#include <memory>
 
#include <easy3d/core/types.h>
#include <easy3d/core/point_cloud.h>
#include <easy3d/core/surface_mesh.h>
 
namespace easy3d {
 
    class Model;
    class Graph;
    class PointsDrawable;
    class LinesDrawable;
    class TrianglesDrawable;

    class Renderer {
    public:
        explicit Renderer(Model *model, bool create_drawables = true);
 
        virtual ~Renderer();

        Model *model() { return model_; }
 
        //-------------------- rendering functionalities  -----------------------

        bool is_visible() const { return visible_; }

        void set_visible(bool b) { visible_ = b; }

        bool is_selected() const { return selected_; }

        void set_selected(bool b);

        void update();
 
        //-------------------- drawable management  -----------------------

        PointsDrawable *get_points_drawable(const std::string &name, bool warning_not_found = true) const;

        LinesDrawable *get_lines_drawable(const std::string &name, bool warning_not_found = true) const;

        TrianglesDrawable *get_triangles_drawable(const std::string &name, bool warning_not_found = true) const;

        PointsDrawable *add_points_drawable(const std::string &name);

        LinesDrawable *add_lines_drawable(const std::string &name);

        TrianglesDrawable *add_triangles_drawable(const std::string &name);

        const std::vector< std::shared_ptr<PointsDrawable> > &points_drawables() const { return points_drawables_; }

        const std::vector< std::shared_ptr<LinesDrawable> > &lines_drawables() const { return lines_drawables_; }

        const std::vector< std::shared_ptr<TrianglesDrawable> > &triangles_drawables() const { return triangles_drawables_; }
 
    public:

        template<typename FT>
        static void color_from_segmentation(
                SurfaceMesh *mesh,
                SurfaceMesh::FaceProperty<FT> segments,
                SurfaceMesh::FaceProperty<vec3> colors
        );

        template<typename FT>
        static void color_from_segmentation(
                SurfaceMesh *mesh,
                SurfaceMesh::VertexProperty<FT> segments,
                SurfaceMesh::VertexProperty<vec3> colors
        );

        template<typename FT>
        static void color_from_segmentation(
                PointCloud *cloud,
                PointCloud::VertexProperty<FT> segments,
                PointCloud::VertexProperty<vec3> colors
        );
 
    private:
        /*
         * @brief Create default drawables for rendering.
         * @details This method creates defaults drawables for rendering a model. The supported default drawables are
         *              - PointCloud: "vertices".
         *              - SurfaceMesh: "faces", "vertices", "edges", "borders".
         *              - Graph: "vertices", "edges".
         *          These drawables are usually sufficient for basic rendering of the model. In case
         *          the default drawables don't meet the particular visualization purpose, you can
         *          override this function or set 'create_default_drawables' to false and create the
         *          drawables by calling Model::add_[type]_drawable().
         */
        void create_default_drawables();
 
        // -------------------------------------------------------------------------------------------------------------
 
        /*
         * @brief Set the default rendering state of the "vertices" drawable of a point cloud.
         * @details The default rendering state is determined by the availability of the vertex properties.
         *          The motivation is that the most appealing rendering is demonstrated by default. The following
         *          priority applies:
         *              1. per-vertex color: in "v:color";
         *              2. per-vertex texture coordinates: in "v:texcoord";
         *              3. segmentation: in "v:primitive_index";
         *              4. scalar field;
         *              5. uniform color.
         */
        void set_default_rendering_state(PointCloud *model, PointsDrawable *drawable);
 
        /*
         * @brief Set the default rendering state of the "faces" drawable of a surface mesh.
         * @details The default rendering state is determined by the availability of the vertex/face properties.
         *          The motivation is that the most appealing rendering is demonstrated by default. The following
         *          priority applies:
         *              1. per-face color: in "f:color";
         *              2. per-vertex color: in "v:color";
         *              3. per-halfedge texture coordinates: in "h:texcoord";
         *              4. per-vertex texture coordinates: in "v:texcoord";
         *              5. segmentation: in "f:chart";
         *              6. scalar field on faces;
         *              7. scalar field on vertices;
         *              8. uniform color
         */
        void set_default_rendering_state(SurfaceMesh *model, TrianglesDrawable *drawable);
 
        /*
         * @brief Set the default rendering state of the "vertices" drawable of a graph.
         * @details The default rendering state is determined by the availability of the vertex properties.
         *          The motivation is that the most appealing rendering is demonstrated by default. The following
         *          priority applies:
         *              1. per-vertex color: in "v:color";
         *              2. per-vertex texture coordinates: in "v:texcoord";
         *              3. scalar field;
         *              4. uniform color.
         */
        void set_default_rendering_state(Graph *model, PointsDrawable *drawable);
 
    protected:
        Model* model_;
 
        bool visible_;
        bool selected_;
 
        std::vector< std::shared_ptr<PointsDrawable> >      points_drawables_;
        std::vector< std::shared_ptr<LinesDrawable> >       lines_drawables_;
        std::vector< std::shared_ptr<TrianglesDrawable> >   triangles_drawables_;
    };
 
}
 
 
 
// ------------------------------------------- Implementation -------------------------------------------
 
 
#include <easy3d/core/random.h>
 
 
namespace easy3d {
 
    template<typename FT> inline
    void Renderer::color_from_segmentation(SurfaceMesh *mesh, SurfaceMesh::FaceProperty<FT> segments,
                                           SurfaceMesh::FaceProperty<vec3> colors) {
        if (mesh->empty()) {
            LOG(WARNING) << "model has no valid geometry";
            return;
        }
 
        if (!segments) {
            LOG(WARNING) << "the surface mesh does not have face property \'" << segments.name() << "\'";
            return;
        }
        if (!colors) {
            LOG(WARNING) << "color property not allocated";
            return;
        }
 
        int max_index = 0;
        for (auto f : mesh->faces())
            max_index = std::max(max_index, static_cast<int>(segments[f]));
 
        // assign each segment a unique color
        std::vector<vec3> color_table(max_index + 1);   // index starts from 0
        for (auto &c : color_table)
            c = random_color();
 
        for (auto f : mesh->faces()) {
            int idx = static_cast<int>(segments[f]);
            if (idx == -1)
                colors[f] = vec3(0, 0, 0);
            else
                colors[f] = color_table[idx];
        }
    }
 
 
    template<typename FT> inline
    void Renderer::color_from_segmentation(SurfaceMesh *mesh, SurfaceMesh::VertexProperty<FT> segments,
                                           SurfaceMesh::VertexProperty<vec3> colors) {
        if (mesh->empty()) {
            LOG(WARNING) << "model has no valid geometry";
            return;
        }
 
        if (!segments) {
            LOG(WARNING) << "the surface mesh does not have vertex property \'" << segments.name() << "\'";
            return;
        }
        if (!colors) {
            LOG(WARNING) << "color property not allocated";
            return;
        }
 
        int max_index = 0;
        for (auto v : mesh->vertices())
            max_index = std::max(max_index, static_cast<int>(segments[v]));
 
        // assign each segment a unique color
        std::vector<vec3> color_table(max_index + 1);   // index starts from 0
        for (auto &c : color_table)
            c = random_color();
 
        for (auto v : mesh->vertices()) {
            int idx = static_cast<int>(segments[v]);
            if (idx == -1)
                colors[v] = vec3(0, 0, 0);
            else
                colors[v] = color_table[idx];
        }
    }
 
 
    template<typename FT> inline
    void Renderer::color_from_segmentation(PointCloud *cloud,
                                           const PointCloud::VertexProperty<FT> segments,
                                           PointCloud::VertexProperty<vec3> colors) {
        if (cloud->empty()) {
            LOG(WARNING) << "model has no valid geometry";
            return;
        }
 
        if (!segments) {
            LOG(WARNING) << "the point cloud does not have vertex property \'" << segments.name() << "\'";
            return;
        }
        if (!colors) {
            LOG(WARNING) << "color property not allocated" << "\'";
            return;
        }
 
        int max_index = 0;
        for (auto v : cloud->vertices())
            max_index = std::max(max_index, static_cast<int>(segments[v]));
 
        // assign each segment a unique color
        std::vector<vec3> color_table(max_index + 1);   // index starts from 0
        for (auto &c : color_table)
            c = random_color();
 
        for (auto v : cloud->vertices()) {
            int idx = static_cast<int>(segments[v]);
            if (idx == -1)
                colors[v] = vec3(0, 0, 0);
            else
                colors[v] = color_table[idx];
        }
    }
 
}
 
 
#endif  // EASY3D_RENDERER_RENDERER_H