curve_segments.hh

#ifndef VTESTBED_GEOMETRY_CURVE_SEGMENTS_HH
#define VTESTBED_GEOMETRY_CURVE_SEGMENTS_HH

#include <vector>

#include <vtestbed/geometry/math.hh>
#include <vtestbed/geometry/types.hh>

namespace vtb {

    namespace geometry {

        template <class T, int N>
        class Curve_segments {

        public:
            using value_type = T;
            using reference = value_type&;
            using const_reference = const value_type&;
            using pointer = value_type*;
            using const_pointer = const value_type*;
            using container_type = std::vector<value_type>;
            using size_type = size_t;
            using vertex_array = std::vector<Vertex<T,N>>;

        private:
            container_type _segments;
            T _min{0}, _max{1};
            T _length{0};

        public:

            inline explicit
            Curve_segments(const vertex_array& points) {
                this->chord_length(points);
            }

            inline void
            chord_length(const vertex_array& values) {
                const auto nvalues = values.size();
                if (nvalues == 0) {
                    return;
                }
                auto& result = this->_segments;
                result.clear();
                result.reserve(nvalues-1);
                T sum{0};
                auto p0 = values.front();
                for (size_t i=1; i<nvalues; ++i) {
                    const auto& p1 = values[i];
                    auto s = distance(p0,p1);
                    result.emplace_back(s);
                    sum += s;
                    p0 = p1;
                }
                this->_length = sum;
                this->_max = sum;
            }

            inline void
            uniform(size_type npoints) {
                if (npoints == 0) {
                    return;
                }
                auto& result = this->_segments;
                result.clear();
                result.reserve(npoints-1);
                T delta = T{1}/(npoints-1);
                for (size_t i=1; i<npoints; ++i) {
                    result.emplace_back(delta);
                }
                this->_length = 1;
                this->_max = 1;
            }

            inline void
            projection(const vertex_array& values, int dim, T z_min, T z_max, T eps=T{}) {
                using std::abs;
                using std::max;
                using std::min;
                const auto nvalues = values.size();
                if (nvalues == 0) { return; }
                auto& result = this->_segments;
                result.clear();
                result.reserve(nvalues-1);
                T sum{0};
                auto p0 = values.front();
                for (size_t i=1; i<nvalues; ++i) {
                    const auto& p1 = values[i];
                    const auto z0 = max(z_min, min(z_max, p0(dim)));
                    const auto z1 = max(z_min, min(z_max, p1(dim)));
                    auto s = z1-z0;
                    if (s < eps) { s = distance(p0,p1); }
                    result.emplace_back(s);
                    sum += s;
                    p0 = p1;
                }
                this->_length = sum;
                this->_max = sum;
            }

            inline void
            projection(const vertex_array& values, int dim, T eps=T{}) {
                this->projection(
                    values,
                    dim,
                    std::numeric_limits<T>::lowest(),
                    std::numeric_limits<T>::max(),
                    eps
                );
            }

            inline void
            normalise() {
                auto& length = this->_length;
                for (auto& s : this->_segments) {
                    s /= length;
                }
                this->_min /= length;
                this->_max /= length;
                length = 1;
            }

            inline void
            locate(T& t, size_type& i) const {
                T new_t = _min + (_max - _min)*t;
                const auto& segments = this->_segments;
                const auto nsegments = segments.size();
                T sum = 0;
                for (; i < nsegments; ++i) {
                    const auto& s = segments[i];
                    T old_sum = sum;
                    sum += s;
                    if (sum > new_t) {
                        t = (new_t - old_sum) / s;
                        break;
                    }
                }
            }

            inline T
            locate(size_type i) const {
                i = std::min(i, this->_segments.size());
                T sum{};
                for (size_type j=0; j<i; ++j) { sum += this->_segments[j]; }
                return sum;
            }

            inline void
            range(T min, T max) {
                this->_min = min;
                this->_max = max;
            }

            inline T
            length() const {
                return this->_length;
            }

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

            inline reference
            operator[](size_type i) {
                return this->_segments[i];
            }

            inline const_reference
            operator[](size_type i) const {
                return this->_segments[i];
            }

            inline pointer
            begin() {
                return this->_segments.data();
            }

            inline const_pointer
            begin() const {
                return this->_segments.data();
            }

            inline pointer
            end() {
                return this->begin() + this->size();
            }

            inline const_pointer
            end() const {
                return this->begin() + this->size();
            }

        private:

        };

    }

}

#endif // vim:filetype=cpp