RouteSegment.cpp

// SPDX-License-Identifier: LGPL-2.1-or-later
//
// SPDX-FileCopyrightText: 2011 Dennis Nienhüser <[email protected]>
//
 
#include "RouteSegment.h"
 
#include "GeoDataLatLonAltBox.h"
 
namespace Marble
{
 
RouteSegment::RouteSegment() :
    m_valid( false ),
    m_distance( 0.0 ),
    m_travelTime( 0 ),
    m_nextRouteSegment( nullptr )
{
    // nothing to do
}
 
qreal RouteSegment::distance() const
{
    return m_distance;
}
 
const Maneuver & RouteSegment::maneuver() const
{
    return m_maneuver;
}
 
void RouteSegment::setManeuver( const Maneuver &maneuver )
{
    m_maneuver = maneuver;
    m_valid = true;
}
 
const GeoDataLineString & RouteSegment::path() const
{
    return m_path;
}
 
void RouteSegment::setPath( const GeoDataLineString &path )
{
    m_path = path;
    m_distance = m_path.length( EARTH_RADIUS );
    m_bounds = m_path.latLonAltBox();
    m_valid = true;
}
 
int RouteSegment::travelTime() const
{
    return m_travelTime;
}
 
void RouteSegment::setTravelTime( int seconds )
{
    m_travelTime = seconds;
    m_valid = true;
}
 
GeoDataLatLonBox RouteSegment::bounds() const
{
    return m_bounds;
}
 
const RouteSegment & RouteSegment::nextRouteSegment() const
{
    if ( m_nextRouteSegment ) {
        return *m_nextRouteSegment;
    }
 
    static RouteSegment invalid;
    return invalid;
}
 
void RouteSegment::setNextRouteSegment( const RouteSegment* segment )
{
    m_nextRouteSegment = segment;
    if ( segment ) {
        m_valid = true;
    }
}
 
bool RouteSegment::isValid() const
{
    return m_valid;
}
 
qreal RouteSegment::distancePointToLine(const GeoDataCoordinates &p, const GeoDataCoordinates &a, const GeoDataCoordinates &b)
{
    return EARTH_RADIUS * p.sphericalDistanceTo(projected(p, a, b));
}
 
GeoDataCoordinates RouteSegment::projected(const GeoDataCoordinates &p, const GeoDataCoordinates &a, const GeoDataCoordinates &b)
{
    qreal const y0 = p.latitude();
    qreal const x0 = p.longitude();
    qreal const y1 = a.latitude();
    qreal const x1 = a.longitude();
    qreal const y2 = b.latitude();
    qreal const x2 = b.longitude();
    qreal const y01 = x0 - x1;
    qreal const x01 = y0 - y1;
    qreal const y21 = x2 - x1;
    qreal const x21 = y2 - y1;
    qreal const len = x21*x21 + y21*y21;
    qreal const t = (x01*x21 + y01*y21) / len;
    if ( t<0.0 ) {
        return a;
    } else if ( t > 1.0 ) {
        return b;
    } else {
        // a + t (b - a);
        qreal const lon = x1 + t * ( x2 - x1 );
        qreal const lat = y1 + t * ( y2 - y1 );
        return GeoDataCoordinates( lon, lat );
    }
 
}
 
qreal RouteSegment::distanceTo( const GeoDataCoordinates &point, GeoDataCoordinates &closest, GeoDataCoordinates &interpolated ) const
{
    Q_ASSERT( !m_path.isEmpty() );
 
    if ( m_path.size() == 1 ) {
        closest = m_path.first();
        return EARTH_RADIUS * m_path.first().sphericalDistanceTo(point);
    }
 
    qreal minDistance = -1.0;
    int minIndex = 0;
    for ( int i=1; i<m_path.size(); ++i ) {
        qreal const distance = distancePointToLine( point, m_path[i-1], m_path[i] );
        if ( minDistance < 0.0 || distance < minDistance ) {
            minDistance = distance;
            minIndex = i;
        }
    }
 
    closest = m_path[minIndex];
    if ( minIndex == 0 ) {
        interpolated = closest;
    } else {
        interpolated = projected( point, m_path[minIndex-1], m_path[minIndex] );
    }
 
    return minDistance;
}
 
qreal RouteSegment::minimalDistanceTo( const GeoDataCoordinates &point ) const
{
    if ( bounds().contains( point) ) {
        return 0.0;
    }
 
    qreal north(0.0), east(0.0), south(0.0), west(0.0);
    bounds().boundaries( north, south, east, west );
    GeoDataCoordinates const northWest( west, north );
    GeoDataCoordinates const northEast( east, north );
    GeoDataCoordinates const southhWest( west, south );
    GeoDataCoordinates const southEast( east, south );
 
    qreal distNorth = distancePointToLine( point, northWest, northEast );
    qreal distEast = distancePointToLine( point, northEast, southEast );
    qreal distSouth = distancePointToLine( point, southhWest, southEast );
    qreal distWest = distancePointToLine( point, northWest, southhWest );
    return qMin( qMin( distNorth, distEast ), qMin( distWest, distSouth ) );
}
 
qreal RouteSegment::projectedDirection(const GeoDataCoordinates &point) const
{
    if (m_path.size() < 2){
        return 0;
    }
 
    qreal minDistance = -1.0;
    int minIndex = 0;
    for ( int i=1; i<m_path.size(); ++i ) {
        qreal const distance = distancePointToLine( point, m_path[i-1], m_path[i] );
        if ( minDistance < 0.0 || distance < minDistance ) {
            minDistance = distance;
            minIndex = i;
        }
    }
 
    if ( minIndex == 0 ) {
        return m_path[0].bearing( m_path[1], GeoDataCoordinates::Degree, GeoDataCoordinates::FinalBearing );
    } else {
        return m_path[minIndex-1].bearing( m_path[minIndex], GeoDataCoordinates::Degree, GeoDataCoordinates::FinalBearing );
    }
}
 
bool RouteSegment::operator ==(const RouteSegment &other) const
{
    return  m_valid == other.m_valid &&
            m_distance == other.m_distance &&
            m_maneuver == other.m_maneuver &&
            m_travelTime == other.m_travelTime &&
            m_bounds == other.m_bounds &&
            m_nextRouteSegment == other.m_nextRouteSegment;
}
 
bool RouteSegment::operator !=(const RouteSegment &other) const
{
    return !(other == *this);
}
 
}