coons_surface.hh

#ifndef VTESTBED_GEOMETRY_COONS_SURFACE_HH
#define VTESTBED_GEOMETRY_COONS_SURFACE_HH

#include <algorithm>
#include <vector>

namespace vtb {

    namespace geometry {

        template <class T, class Curve>
        class Coons_surface {

        public:
            using curve_type = Curve;
            using value_type = typename curve_type::value_type;
            using size_type = size_t;

        private:
            curve_type _c0, _c1, _d0, _d1;
            T _u_min{0}, _u_max{1};
            T _v_min{0}, _v_max{1};

        public:

            inline explicit
            Coons_surface(
                const curve_type& c0,
                const curve_type& c1,
                const curve_type& d0,
                const curve_type& d1
            ): _c0(c0), _c1(c1), _d0(d0), _d1(d1) {}

            inline value_type
            operator()(T u, T v) const {
                T u1 = T{1} - u;
                T v1 = T{1} - v;
                value_type c = _c0(u)*v1 + _c1(u)*v;
                value_type d = _d0(v)*u1 + _d1(v)*u;
                value_type p00 = _c0(_u_min);
                value_type p01 = _c0(_u_max);
                value_type p10 = _c1(_u_min);
                value_type p11 = _c1(_u_max);
                value_type cd = p00*u1*v1 + p01*u*v1 + p10*u1*v + p11*u*v;
                return c + d - cd;
            }

            inline void
            u_range(T min, T max) {
                this->_u_min = min;
                this->_u_max = max;
            }

            inline size_type
            max_size_u() const {
                return std::max(this->_c0.size(), this->_c1.size());
            }

            inline size_type
            max_size_v() const {
                return std::max(this->_d0.size(), this->_d1.size());
            }

        };

    }

}


#endif // vim:filetype=cpp