lineutils.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "mathutils.h"
 
// External Includes
#include <vector>
#include <unordered_map>
#include <map>
 
namespace nap
{
    namespace math
    {
        template<typename T>
        void getValueAlongLine(const std::vector<T>& vertexData, float location, bool closed, T& outValue);
 
        template<typename T>
        int resampleLine(std::vector<T>& vertices, std::vector<T>& buffer, int segments, bool closed);
 
        float NAPAPI getDistancesAlongLine(const std::vector<glm::vec3>& vertexPositions, std::map<float, int>& outDistances, bool loop);
 
        float NAPAPI getVertexLerpValue(const std::map<float, int>& distanceMap, float location, int& outMinVertex, int& outMaxVertex);
 
        template<typename T>
        void getValueAlongLine(const std::map<float, int>& distanceMap, const std::vector<T>& vertexData, float location, T& outValue);
 
        void NAPAPI getNormalAlongLine(const std::map<float, int>& distanceMap, const std::vector<glm::vec3>& vertexNormals, float location, glm::vec3& outNormal);
 
 
        // Template definitions
 
        template<typename T>
        void getValueAlongLine(const std::vector<T>& vertexData, float location, bool closed, T& outValue)
        {
            // Get vertex range, when the line is closed it means that we want to
            // include the first vertex as last
            int vert_count = static_cast<int>(vertexData.size());
            assert(vert_count > 0);
            int range = closed ? vert_count : vert_count - 1;
 
            // Get interpolation location
            float loc = location * static_cast<float>(range);
 
            // Get min and max point bounds, wrap the last vertex if the line is closed
            // ie: the last vertex is the first vertex
            int min_vertex = static_cast<int>(math::floor<float>(loc));
            int max_vertex = static_cast<int>(math::ceil<float>(loc));
 
            min_vertex = min_vertex % vert_count;
            max_vertex = max_vertex % vert_count;
 
            // Get lerp value that sits in between min / max
            float lerp_v = loc - static_cast<float>(static_cast<int>(loc));
 
            // Ensure points are in bounds
            assert(min_vertex <= vert_count - 1);
            assert(max_vertex <= vert_count - 1);
 
            // Lerp between min and max value
            const T& min_p_value = vertexData[min_vertex];
            const T& max_p_value = vertexData[max_vertex];
 
            outValue = math::lerp<T>(min_p_value, max_p_value, lerp_v);
        }
 
 
        template<typename T>
        int resampleLine(std::vector<T>& vertices, std::vector<T>& buffer, int segments, bool closed)
        {
            assert(segments > 0);
            int vertex_count = static_cast<int>(vertices.size());
 
            // If there not enough or an equal amount or less vertices, don't do anything
            if (segments <= vertex_count || vertex_count < 2)
            {
                buffer = vertices;
                return vertices.size();
            }
 
            // Figure out the amount of edges, closed lines have one extra edge (connecting first to last)
            int edge_count = closed ? vertex_count : vertex_count - 1;
 
            // Calculate the total amount of pointer for every side
            int pps = segments / edge_count;
 
            // Clear existing buffer data
            buffer.clear();
 
            // Reserve space for points to add
            buffer.reserve(segments);
 
            for (int i = 0; i < edge_count; i++)
            {
                // Get edge points
                T& point_one = vertices[i];
                T& point_two = i + 1 >= vertex_count ? vertices[0] : vertices[i + 1];
 
                // Add edge vertices
                for (int p = 0; p < pps; p++)
                {
                    float inc = static_cast<float>(p) / static_cast<float>(pps);
                    buffer.emplace_back(nap::math::lerp<T>(point_one, point_two, inc));
                }
            }
 
            // If the line is open add an additional point
            if (!closed)
            {
                buffer.emplace_back(vertices.back());
            }
 
            // Return total number of new points
            return buffer.size();
        }
 
 
        template<typename T>
        void getValueAlongLine(const std::map<float, int>& distances, const std::vector<T>& vertexData, float location, T& outValue)
        {
            int vert_min, vert_max;
            float lerp_v = getVertexLerpValue(distances, location, vert_min, vert_max);
 
            // Get the values to interpolate
            const T& lower_value = vertexData[vert_min];
            const T& upper_value = vertexData[vert_max];
 
            outValue = math::lerp<T>(lower_value, upper_value, lerp_v);
        }
    }
}