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 <easy3d/core/types.h>
#include <easy3d/core/point_cloud.h>
#include <easy3d/core/surface_mesh.h>
 
namespace easy3d {
 
    class Model;
    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) const;
 
        LinesDrawable *get_lines_drawable(const std::string &name) const;
 
        TrianglesDrawable *get_triangles_drawable(const std::string &name) 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<PointsDrawable *> &points_drawables() const { return points_drawables_; }
 
        const std::vector<LinesDrawable *> &lines_drawables() const { return lines_drawables_; }
 
        const std::vector<TrianglesDrawable *> &triangles_drawables() const { return triangles_drawables_; }
 
    public:
        static void create_default_drawables(Model *model);
 
        // -------------------------------------------------------------------------------------------------------------
 
        static void set_default_rendering_state(PointCloud *model, PointsDrawable *drawable);
 
        static void set_default_rendering_state(SurfaceMesh *model, TrianglesDrawable *drawable);
 
        // -------------------------------------------------------------------------------------------------------------
 
        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
        );
 
    protected:
        Model *model_;
 
        bool visible_;
        bool selected_;
 
        std::vector<PointsDrawable *> points_drawables_;
        std::vector<LinesDrawable *> lines_drawables_;
        std::vector<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