spline_surface.hh

#ifndef VTESTBED_GEOMETRY_SPLINE_SURFACE_HH
#define VTESTBED_GEOMETRY_SPLINE_SURFACE_HH

#include <vtestbed/geometry/polyhedron.hh>

namespace vtb {

    namespace geometry {

        template <class T, class Curve>
        class Spline_surface {

        public:
            using curve_type = Curve;
            using value_type = typename curve_type::value_type;
            using reference = value_type&;
            using const_reference = const value_type&;
            using container_type = std::vector<curve_type>;
            using size_type = size_t;
            using pointer = curve_type*;
            using const_pointer = const curve_type*;
            using polyhedron_type = Polyhedron<T,3>;

        private:
            container_type _curves;

        public:

            inline explicit
            Spline_surface(const container_type& curves):
            _curves(curves) {}

            inline curve_type
            operator()(T u) const {
                std::vector<value_type> points;
                points.reserve(this->_curves.size());
                for (const auto& curve : this->_curves) {
                    points.emplace_back(curve(u));
                }
                return curve_type(points);
            }

            inline value_type
            operator()(T u, T v) const {
                return this->operator()(u)(v);
            }

            inline value_type
            operator()(const Vertex<T,2>& v) const {
                return this->operator()(v(0), v(1));
            }

            inline size_type
            size_v() const {
                return this->_curves.size();
            }

            inline size_type
            max_size_u() const {
                size_type max_s = 0;
                for (const auto& s : this->_curves) {
                    size_type new_s = s.size();
                    if (new_s > max_s) { max_s = new_s; }
                }
                return max_s;
            }

            inline const curve_type& operator[](size_type i) const { return this->_curves[i]; }
            inline curve_type& operator[](size_type i) { return this->_curves[i]; }
            inline size_type size() const { return this->_curves.size(); }
            inline const_pointer begin() const { return this->_curves.data(); }
            inline pointer begin() { return this->_curves.data(); }
            inline const_pointer end() const { return this->_curves.data() + size(); }
            inline pointer end() { return this->_curves.data() + size(); }

            inline Polyhedron<T,3>
            polyhedron(size_type resolution_u, size_type resolution_v) const {
                using vertex_array = typename polyhedron_type::vertex_array;
                using face_array = typename polyhedron_type::face_array;
                using index_type = typename vtb::geometry::Face<3>::value_type;
                index_type nrows = this->_curves.size()*resolution_u;
                index_type ncols = this->_curves.front().size()*resolution_v;
                face_array faces;
                vertex_array vertices;
                vertices.reserve(ncols*nrows);
                faces.reserve(ncols*nrows);
                T du = T{1}/(nrows-1);
                T dv = T{1}/(ncols-1);
                for (index_type i=0; i<nrows; ++i) {
                    const auto& curve = (*this)(i*du);
                    for (index_type j=0; j<ncols; ++j) {
                        const auto& v2 = curve(j*dv);
                        vertices.emplace_back();
                        auto& v1 = vertices.back();
                        for (int i=0; i<3; ++i) {
                            v1(i) = v2(i);
                        }
                    }
                }
                for (index_type i=1; i<nrows; ++i) {
                    for (index_type j=1; j<ncols; ++j) {
                        auto i1 = ncols*(i-1) + (j-1);
                        auto i2 = ncols*(i-1) + j;
                        auto i3 = ncols*i + j;
                        auto i4 = ncols*i + (j-1);
                        faces.emplace_back(i1, i2, i3);
                        faces.emplace_back(i1, i3, i4);
                    }
                }
                polyhedron_type result(vertices, faces);
                result.unique();
                result.normalise();
                return result;
            }

        };

    }

}

#endif // vim:filetype=cpp