#include <src/libslic3r/Geometry/Curves.hpp>

Public Types
using	Kernel = KernelType

Public Member Functions
Vec< Dimension, NumberType >	get_fitted_value (const NumberType &observation_point) const

Public Attributes
Eigen::MatrixXf	coefficients

NumberType	start

NumberType	segment_size

size_t	endpoints_level_of_freedom

Detailed Description

template<size_t Dimension, typename NumberType, typename KernelType>
struct Slic3r::Geometry::PiecewiseFittedCurve< Dimension, NumberType, KernelType >

Member Typedef Documentation

◆ Kernel

template<size_t Dimension, typename NumberType , typename KernelType >

using Slic3r::Geometry::PiecewiseFittedCurve< Dimension, NumberType, KernelType >::Kernel = KernelType

Member Function Documentation

◆ get_fitted_value()

template<size_t Dimension, typename NumberType , typename KernelType >

Vec< Dimension, NumberType > Slic3r::Geometry::PiecewiseFittedCurve< Dimension, NumberType, KernelType >::get_fitted_value ( const NumberType & observation_point ) const

inline

                                                                                           {
        Vec<Dimension, NumberType> result = Vec<Dimension, NumberType>::Zero();
 
        //find corresponding segment index; expects kernels to be centered
        int middle_right_segment_index = floor((observation_point - start) / segment_size);
        //find index of first segment that is affected by the point i; this can be deduced from kernel_span
        int start_segment_idx = middle_right_segment_index - Kernel::kernel_span / 2 + 1;
        for (int segment_index = start_segment_idx; segment_index < int(start_segment_idx + Kernel::kernel_span);
                segment_index++) {
            NumberType segment_start = start + segment_index * segment_size;
            NumberType normalized_segment_distance = (segment_start - observation_point) / segment_size;
 
            int parameter_index = segment_index + endpoints_level_of_freedom;
            parameter_index = std::clamp(parameter_index, 0, int(coefficients.cols()) - 1);
            result += Kernel::kernel(normalized_segment_distance) * coefficients.col(parameter_index);
        }
        return result;
    }