point.h

Go to the documentation of this file.

 
#pragma once
 
#include "../../range.h"
#include "./vec_point_base.h"
#include "./vector.h"
 
namespace emlabcpp
{
 
template < std::size_t N >
class point : public vec_point_base< point< N >, N >
{
public:
        using vec_point_base< point, N >::vec_point_base;
 
        constexpr point< N >& operator+=( vector< N > const& other )
        {
                for ( std::size_t const i : range( N ) )
                        ( *this )[i] += other[i];
                return *this;
        }
 
        constexpr point< N >& operator-=( vector< N > const& other )
        {
                for ( std::size_t const i : range( N ) )
                        ( *this )[i] -= other[i];
                return *this;
        }
 
        ~point() = default;
};
 
template < std::size_t N >
constexpr point< N > point_cast( vector< N > const& v )
{
        return point< N >{ *v };
}
 
template < std::size_t N >
constexpr vector< N > vector_cast( point< N > const& p )
{
        return vector< N >{ *p };
}
 
template < std::size_t N >
[[deprecated]] constexpr point< N > operator*( point< N > a, point< N > const& b )
{
        for ( std::size_t const i : range( N ) )
                a[i] *= b[i];
        return a;
}
 
template < std::size_t N >
constexpr vector< N > operator-( point< N > a, point< N > const& b )
{
        a -= vector_cast( b );
        return vector< N >{ *a };
}
 
template < std::size_t N >
constexpr point< N > operator+( point< N > a, vector< N > const& b )
{
        a += b;
        return a;
}
 
template < std::size_t N >
constexpr point< N > operator-( point< N > a, vector< N > const& b )
{
        a -= b;
        return a;
}
 
template < std::size_t N >
constexpr float distance_of( point< N > const& a, point< N > const& b )
{
        auto tmp = sum( range( N ), [&]( std::size_t i ) {
                return std::pow( a[i] - b[i], 2 );
        } );
        return std::sqrt( float( tmp ) );
}
 
template < std::size_t N >
constexpr float point_angle( point< N > const& a, point< N > const& b )
{
        return vector_angle( vector_cast( a ), vector_cast( b ) );
}
 
template < std::size_t N >
inline std::vector< point< N > >
lineary_interpolate_path( std::vector< point< N > > const& ipath, float d_step )
{
        std::vector< point< N > > res;
        if ( ipath.empty() )
                return res;
        for ( std::size_t i : range( ipath.size() - 1 ) ) {
                point< N > const& from = ipath[i];
                point< N > const& to   = ipath[i + 1];
 
                std::size_t const seg_steps = std::size_t{ distance_of( from, to ) / d_step };
                for ( std::size_t const j : range( seg_steps ) )
                        res.push_back( lin_interp( from, to, float( j ) / float( seg_steps ) ) );
        }
        res.push_back( ipath.back() );
        return res;
}
 
template < std::size_t N >
constexpr float axis_projection_distance( point< N > const& a, vector< N > const& axis_direction )
{
        return float( dot( vector_cast( a ), axis_direction ) );
}
}  // namespace emlabcpp