PolyLine.hpp

#pragma once
 
#include <Core/Containers/VectorArray.hpp>
#include <Core/Geometry/DistanceQueries.hpp>
#include <Core/Math/LinearAlgebra.hpp> // cotan, saturate (from Math.hpp)
#include <Core/RaCore.hpp>
#include <Core/Types.hpp>
 
namespace Ra {
namespace Core {
namespace Geometry {
class RA_CORE_API PolyLine
{
 
  public:
    explicit PolyLine( const Vector3Array& pt );
 
    inline const Vector3Array& getPoints() const;
 
    inline void getSegment( uint segment, Vector3& aOut, Vector3& abOut ) const;
 
    inline const Vector3Array& getSegmentVectors() const;
 
    inline Aabb aabb() const;
 
    inline Scalar length() const;
 
    void setPoints( const Vector3Array& pt );
 
    Scalar squaredDistance( const Vector3& p ) const;
 
    Scalar distance( const Vector3& p ) const;
 
    Scalar projectOnSegment( const Vector3& p, uint segment ) const;
 
    uint getNearestSegment( const Vector3& p ) const;
 
    inline uint getSegmentIndex( Scalar t ) const;
 
    Scalar project( const Vector3& p ) const;
 
    Vector3 f( Scalar t ) const;
 
  protected:
    void update();
 
    inline Scalar getLineParameter( uint segment, Scalar tSegment ) const;
 
  private:
    // Stores the points Pi
    Vector3Array m_pts;
    // Stores the vectors (Pi+1 - Pi)
    Vector3Array m_ptsDiff;
    // Length from origin to point Pi+1.
    std::vector<Scalar> m_lengths;
};
 
const Vector3Array& PolyLine::getPoints() const {
    return m_pts;
}
 
Scalar PolyLine::length() const {
    return m_lengths.back();
}
 
Aabb PolyLine::aabb() const {
    Aabb aabb;
    for ( const auto& v : m_pts ) {
        aabb.extend( v );
    }
    return aabb;
}
 
Scalar PolyLine::getLineParameter( uint segment, Scalar tSegment ) const {
    CORE_ASSERT( segment < m_ptsDiff.size(), "invalid segment index" );
    const Scalar lprev    = segment > 0 ? m_lengths[segment - 1] : 0;
    const Scalar lSegment = m_lengths[segment] - lprev;
    return ( ( lSegment * tSegment ) + lprev ) / length();
}
 
void PolyLine::getSegment( uint segment, Vector3& aOut, Vector3& abOut ) const {
    CORE_ASSERT( segment < m_ptsDiff.size(), "Invalid segment index." );
    aOut  = m_pts[segment];
    abOut = m_ptsDiff[segment];
}
 
const Vector3Array& PolyLine::getSegmentVectors() const {
    return m_ptsDiff;
}
 
uint PolyLine::getSegmentIndex( Scalar t ) const {
    // This could be optimized by dichotomy
    Scalar param = length() * Math::saturate( t );
    uint i       = 0;
    while ( m_lengths[i] < param ) {
        ++i;
    }
    return i;
}
 
} // namespace Geometry
} // namespace Core
} // namespace Ra