ShapeBase.h

Go to the documentation of this file.

#ifndef SHAPE_BASE_H
#define SHAPE_BASE_H
 
#include <memory>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
 
template <typename T>
class ShapeBase
{
    protected:
        std::vector<std::vector<T>> m_vertex_list{};  // List of vertex coordinates (n x 3)
        std::vector<std::vector<int>>
            m_face_list;  // List of faces, returning their corresponding vertices (n x X), X
                          // depending on face type (tris: X = 3, quads: X = 4...)
        std::vector<std::vector<T>> m_face_normals{};  // List of face normals (n x 3)
        std::vector<T> m_face_areas{};                 // List of areas of the faces
 
    public:
        const std::vector<std::vector<T>>& getVertices() const { return m_vertex_list; }
        const std::vector<std::vector<int>>& getFaces() const { return m_face_list; }
        const std::vector<std::vector<T>>& getNormals() const { return m_face_normals; }
        const std::vector<T>& getAreas() const { return m_face_areas; }
        int getNumberOfFacets() const { return m_face_areas.size(); }
 
        void setVertices(const std::vector<std::vector<T>> vertex_list)
        {
            m_vertex_list = vertex_list;
        }
        void setFaces(const std::vector<std::vector<int>>& face_list) { m_face_list = face_list; }
        void setNormals(const std::vector<std::vector<T>> face_normals)
        {
            m_face_normals = face_normals;
        }
        void setAreas(const std::vector<T> face_areas) { m_face_areas = face_areas; }
 
        void validityCheck();
 
        ShapeBase();
        ShapeBase(std::vector<std::vector<T>> vertex_list, std::vector<std::vector<int>> face_list,
                  std::vector<std::vector<T>> face_normals, std::vector<T> face_areas);
        ~ShapeBase() = default;
};
 
template <typename T>
ShapeBase<T>::ShapeBase()
{
}
 
template <typename T>
ShapeBase<T>::ShapeBase(std::vector<std::vector<T>> vertex_list,
                        std::vector<std::vector<int>> face_list,
                        std::vector<std::vector<T>> face_normals, std::vector<T> face_areas)
    : m_vertex_list{vertex_list},
      m_face_list{std::move(face_list)},
      m_face_normals{face_normals},
      m_face_areas{face_areas}
{
}
 
template <typename T>
void ShapeBase<T>::validityCheck()
{
    // Check if the three vectors that are required to have identical length do infact have
    // identical length
    bool equal_size{m_face_list.size() == m_face_normals.size()
                    && m_face_normals.size() == m_face_areas.size()
                    and m_face_areas.size() == m_face_list.size()};
    // Check if the mesh consists of at least one facet (at least one "Tri")
    bool valid_length{m_vertex_list.size() > 3 && !m_face_list.empty()};
    if (!equal_size && !valid_length)
    {
        std::string error_msg{
            "The supplied lists for the normals, faces and areas of lengths "
            + std::to_string(m_face_normals.size()) + ", " + std::to_string(m_face_list.size())
            + ", " + std::to_string(m_face_areas.size())
            + " are not matching in length and the mesh does not contain a valid facet!\n"};
        throw std::runtime_error(error_msg.c_str());
    }
    if (!equal_size)
    {
        std::string error_msg{
            "The supplied lists for the normals, faces and areas of lengths "
            + std::to_string(m_face_normals.size()) + ", " + std::to_string(m_face_list.size())
            + ", " + std::to_string(m_face_areas.size()) + " are not matching in length!\n"};
        throw std::runtime_error(error_msg.c_str());
    }
    else if (!valid_length)
    {
        throw std::runtime_error("The mesh does not contain a valid facet!\n");
    };
}
 
#endif