Mesh.h

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <numeric> // for std::accumulate
#include <vector>
 
#include <Eigen/Core>
 
#include <RobotAPI/interface/ArViz/Elements.h>
 
#include "ElementOps.h"
 
namespace CGAL
{
    template <class PolyhedronTraits_3,
              class PolyhedronItems_3,
              template <class T, class I, class A>
              class T_HDS,
              class Alloc>
    class Polyhedron_3;
    template <class>
    class Surface_mesh;
} // namespace CGAL
 
namespace armarx::viz
{
 
    class Mesh : public ElementOps<Mesh, data::ElementMesh>
    {
    public:
        using ElementOps::ElementOps;
 
        Mesh&
        vertices(const Eigen::Vector3f* vs, std::size_t size)
        {
            auto& vertices = data_->vertices;
            vertices.clear();
            vertices.reserve(size);
 
            for (std::size_t i = 0; i < size; ++i)
            {
                vertices.push_back(armarx::Vector3f{vs[i].x(), vs[i].y(), vs[i].z()});
            }
 
            return *this;
        }
 
        Mesh&
        vertices(const std::vector<Eigen::Vector3f>& vs)
        {
            return this->vertices(vs.data(), vs.size());
        }
 
        Mesh&
        vertices(const armarx::Vector3f* vs, std::size_t size)
        {
            data_->vertices.assign(vs, vs + size);
 
            return *this;
        }
 
        Mesh&
        vertices(const std::vector<armarx::Vector3f>& vs)
        {
            return this->vertices(vs.data(), vs.size());
        }
 
        Mesh&
        colors(const data::Color* cs, std::size_t size)
        {
            data_->colors.assign(cs, cs + size);
 
            return *this;
        }
 
        Mesh&
        colors(const std::vector<data::Color>& cs)
        {
            return this->colors(cs.data(), cs.size());
        }
 
        Mesh&
        faces(const data::Face* fs, std::size_t size)
        {
            data_->faces.assign(fs, fs + size);
 
            return *this;
        }
 
        Mesh&
        faces(const std::vector<data::Face>& fs)
        {
            return this->faces(fs.data(), fs.size());
        }
 
        template <class T>
        Mesh& mesh(const CGAL::Surface_mesh<T>& sm);
 
        template <class PolyhedronTraits_3,
                  class PolyhedronItems_3,
                  template <class T, class I, class A>
                  class T_HDS,
                  class Alloc>
        Mesh&
        mesh(const CGAL::Polyhedron_3<PolyhedronTraits_3, PolyhedronItems_3, T_HDS, Alloc>& p3);
        /**
         * @brief Builds a regular 2D grid in the xy-plane.
         * @param extents The full extents in x and y direction.
         * @param numPoints The number of points in x and y direction.
         * @param colorFunc A function determining the color of each vertex.
         */
        Mesh&
        grid2D(Eigen::Vector2f extents,
               Eigen::Vector2i numPoints,
               std::function<viz::Color(size_t i, size_t j, const Eigen::Vector3f& p)> colorFunc);
 
        /**
         * @brief Builds a regular 2D grid.
         *
         * The shape of `vertices` and `colors` must match, i.e.:
         * - `vertices` and `colors` must have equal size.
         * - Each element (nested vector) of `vertices` and `colors` must have equal size.
         *
         * @param vertices The vertices.
         * @param colors The colors.
         */
        Mesh& grid2D(const std::vector<std::vector<Eigen::Vector3f>>& vertices,
                     const std::vector<std::vector<viz::data::Color>>& colors);
    };
 
    namespace grid
    {
        /**
         * @brief Builds vertices of a regular 2D grid in the xy-plane.
         *
         * If the result is indexed as result[i][j], the i index represents the x-axis,
         * the j index represents the y-axis.
         *
         * @param extents The full extents per axis.
         * @param numPoints The number of points per axis.
         * @param height The height (z-value).
         * @return The vertices.
         */
        std::vector<std::vector<Eigen::Vector3f>>
        makeGrid2DVertices(Eigen::Vector2f extents, Eigen::Vector2i numPoints, float height = 0);
 
 
        /**
         * @brief Build colors of a 2D grid.
         * @param vertices The vertices.
         * @param colorFunc A function determining the color of each vertex.
         * @return The colors.
         *
         * @see `makeGrid2DVertices()`
         */
        std::vector<std::vector<viz::data::Color>> makeGrid2DColors(
            const std::vector<std::vector<Eigen::Vector3f>>& vertices,
            std::function<viz::Color(size_t x, size_t y, const Eigen::Vector3f& p)> colorFunc);
 
 
        /**
         * @brief Builds faces of a 2D grid.
         *
         * The built indexes refer to flattened arrays of vertices and colors,
         * such as produced by `flatten()` applied to the result of `makeGrid2DVertices()`.
         *
         * @param num_x The number of vertices in x-axis.
         * @param num_y The number of vertices in y-axis.
         * @return The faces.
         */
        std::vector<viz::data::Face> makeGrid2DFaces(size_t num_x, size_t num_y);
 
        template <class T>
        /// @brief Flattens a 2D vector of nested vectors to a 1D vector.
        std::vector<T>
        flatten(const std::vector<std::vector<T>>& vector)
        {
            size_t size = std::accumulate(vector.begin(),
                                          vector.end(),
                                          size_t(0),
                                          [](size_t s, const auto& v) { return s + v.size(); });
 
            std::vector<T> flat;
            flat.reserve(size);
            for (const auto& v : vector)
            {
                for (const auto& val : v)
                {
                    flat.push_back(val);
                }
            }
            return flat;
        }
    } // namespace grid
 
} // namespace armarx::viz