vertex_set.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/shape.hpp>
#include <kernel/util/tiny_algebra.hpp>
#include <kernel/adjacency/permutation.hpp>
 
// includes, system
#include <vector>
 
namespace FEAT
{
  namespace Geometry
  {
    template<
      int num_coords_,
      typename Coord_ = Real>
    struct VertexSet
    {
      static_assert(num_coords_ > 0, "invalid num_coords_ parameter");
 
    public:
      static constexpr int num_coords = num_coords_;
 
      typedef Coord_ CoordType;
 
      typedef Tiny::Vector<CoordType, num_coords> VertexType;
 
    protected:
      std::vector<VertexType> _vertices;
 
      template<int sm_, int sn_, int sv_>
      static void _aux_rot_mat(
        Tiny::Matrix<CoordType, 1, 1, sm_, sn_>& r,
        const Tiny::Vector<CoordType, 1, sv_>&)
      {
        r.set_identity();
      }
 
      template<int sm_, int sn_, int sv_>
      static void _aux_rot_mat(
        Tiny::Matrix<CoordType, 2, 2, sm_, sn_>& r,
        const Tiny::Vector<CoordType, 2, sv_>& a)
      {
        r.set_rotation_2d(a[0]);
      }
 
      template<int sm_, int sn_, int sv_>
      static void _aux_rot_mat(
        Tiny::Matrix<CoordType, 3, 3, sm_, sn_>& r,
        const Tiny::Vector<CoordType, 3, sv_>& a)
      {
        r.set_rotation_3d(a[0], a[1], a[2]);
      }
 
 
      explicit VertexSet(const std::vector<VertexType>& vtx) :
        _vertices(vtx)
      {
      }
 
    public:
      VertexSet() :
        _vertices()
      {
      }
 
      explicit VertexSet(Index num_vertices) :
        _vertices(std::size_t(num_vertices))
      {
      }
 
      VertexSet(VertexSet&& other) :
        _vertices(std::forward<std::vector<VertexType>>(other._vertices))
      {
      }
 
      VertexSet& operator=(VertexSet&& other)
      {
        // avoid self-move
        if(this == &other)
          return *this;
        _vertices = std::forward<std::vector<VertexType>>(other._vertices);
        return *this;
      }
 
      virtual ~VertexSet()
      {
      }
 
      VertexSet clone() const
      {
        return VertexSet(this->_vertices);
      }
 
      template<typename DT2_>
      std::vector<Tiny::Vector<DT2_,num_coords>> clone_internal_vector() const
      {
        std::vector<Tiny::Vector<DT2_,num_coords>> tmp(_vertices.size());
        for(std::size_t i = 0; i < std::size_t(_vertices.size()); ++i)
        {
          for(int j = 0; j < num_coords; ++j)
            tmp[i][j] = DT2_(_vertices[i][j]);
        }
        return tmp;
      }
 
      std::size_t bytes() const
      {
        return _vertices.size() * sizeof(VertexType);
      }
 
      int get_num_coords() const
      {
        return num_coords_;
      }
 
      Index get_num_vertices() const
      {
        return Index(_vertices.size());
      }
 
      VertexType& operator[](Index i)
      {
        ASSERT(i < get_num_vertices());
        return _vertices[i];
      }
 
      const VertexType& operator[](Index i) const
      {
        ASSERT(i < get_num_vertices());
        return _vertices[i];
      }
 
      VertexType* begin()
      {
        return &_vertices[0];
      }
 
      const VertexType* begin() const
      {
        return &_vertices[0];
      }
 
      VertexType* end()
      {
        return &_vertices.back() + 1;
      }
 
      const VertexType* end() const
      {
        return &_vertices.back() + 1;
      }
 
      void transform(const VertexType& origin, const VertexType& angles, const VertexType& offset)
      {
        // create rotation matrix
        Tiny::Matrix<CoordType, num_coords_, num_coords_> rot;
        _aux_rot_mat(rot, angles);
 
        // transform all vertices
        for(auto& v : _vertices)
        {
          v.set_mat_vec_mult(rot, v - origin) += offset;
        }
      }
 
      void permute(const Adjacency::Permutation& perm, bool invert = false)
      {
        if(!perm.empty() && !_vertices.empty())
        {
          XASSERT(Index(_vertices.size()) == perm.size());
          perm.apply(_vertices.data(), invert);
        }
      }
 
      static String name()
      {
        return "VertexSet<...>";
      }
    }; // class VertexSet<...>
 
  } // namespace Geometry
} // namespace FEAT