NURBSPatch_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_DOMAINS_NURBSPATCH_FWD_HPP_
#define MEDUSA_BITS_DOMAINS_NURBSPATCH_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <medusa/bits/types/Vec.hpp>
#include <medusa/bits/types/Range.hpp>
#include <medusa/bits/domains/BoxShape.hpp>
#include <memory>
 
namespace mm {
 
namespace nurbs_patch_internal {
template <typename vec_t, typename param_vec_t>
struct NURBSPatchHelper {};
 
template<size_t dim, typename T>
struct NestedRange{
    typedef Range<typename NestedRange<dim - 1, T>::type> type;
};
 
template<typename T>
struct NestedRange<0, T>{
    typedef T type;
};
}  // namespace nurbs_patch_internal
 
template <typename vec_t, typename param_vec_t>
class NURBSPatch {
    friend struct nurbs_patch_internal::NURBSPatchHelper<vec_t, param_vec_t>;
 
  public:
    typedef typename vec_t::scalar_t scalar_t;  
    enum {  dim = vec_t::dim, proj_dim = dim + 1, param_dim = param_vec_t::dim};
    typedef Vec<scalar_t, proj_dim> proj_vec_t;  
 
    template <typename T>
    using NdRange = typename nurbs_patch_internal::NestedRange<param_dim, T>::type;
 
  private:
    std::array<int, param_dim> p;  
    NdRange<proj_vec_t> weighted_control_points;  
    std::array<Range<scalar_t>, param_dim> knots;  
 
    std::unique_ptr<std::array<NURBSPatch<vec_t, param_vec_t>, param_dim>> der_structure;
 
  public:
    NURBSPatch(const NdRange<proj_vec_t>& wcp,
               const std::array<Range<scalar_t>, param_dim>& ks,
               const std::array<int, param_dim>& in_p);
 
    NURBSPatch(const NdRange<vec_t>& cp, const NdRange<double>& w,
               const std::array<Range<scalar_t>, param_dim>& ks,
               const std::array<int, param_dim>& in_p);
 
    NURBSPatch(const NURBSPatch<vec_t, param_vec_t>& patch) noexcept;
 
    NURBSPatch<vec_t, param_vec_t>& operator=(const NURBSPatch<vec_t, param_vec_t>&) noexcept;
 
    NURBSPatch(NURBSPatch<vec_t, param_vec_t>&&) noexcept = default;
    NURBSPatch<vec_t, param_vec_t>& operator=(NURBSPatch<vec_t, param_vec_t>&&) noexcept = default;
 
    void computeDerivativeStructure();
 
    vec_t evaluate(const param_vec_t& t, scalar_t* w) const;
 
    vec_t evaluate(const param_vec_t& t) const;
 
    proj_vec_t evaluateWeighted(const param_vec_t& t) const;
 
    Eigen::Matrix<scalar_t, dim, param_dim> jacobian(const param_vec_t& t, const vec_t& pt,
                                                     const scalar_t& w) const;
 
    Eigen::Matrix<scalar_t, dim, param_dim> jacobian(const param_vec_t& t) const;
 
    std::pair<vec_t, Eigen::Matrix<scalar_t, dim, param_dim>> evaluatePointAndJacobian(
            const param_vec_t& t) const;
 
    BoxShape<param_vec_t> getDomain() const;
 
    Range<NURBSPatch<vec_t, Vec<scalar_t, param_dim - 1>>> getBoundaries() const;
 
    param_vec_t getPatchParameterFromBoundaryParameter(const Vec<scalar_t, param_dim - 1>& t, int i,
                                                       scalar_t epsilon = 0) const;
 
    Vec<scalar_t, param_dim - 1> getBoundaryParameterFromPatchParameter(const param_vec_t& t,
                                                                        int i) const;
};
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_DOMAINS_NURBSPATCH_FWD_HPP_