laneposition.h

Go to the documentation of this file.

/********************************************************************************
 * Copyright (C) 2017-2020 German Aerospace Center (DLR). 
 * Eclipse ADORe, Automated Driving Open Research https://eclipse.org/adore
 *
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0 
 *
 * Contributors: 
 *   Daniel Heß - initial API and implementation
 ********************************************************************************/
 
 
#pragma once
#include <adore/env/borderbased/borderid.h>
 
namespace adore
{
    namespace env
    {
        namespace BorderBased
        {
            struct LanePosition
            {
                BorderID m_rightID; 
                double m_progress; 
                LanePosition() {}
                LanePosition(const BorderID& id, double progress)
                {
                    m_rightID = BorderID(id);
                    m_progress = progress;
                }
                LanePosition(const LanePosition& pos)
                {
                    m_rightID = BorderID(pos.m_rightID);
                    m_progress = pos.m_progress;
                }
                void translate(double dx,double dy,double dz)
                {
                    m_rightID.translate(dx,dy,dz);
                }
                void rotate(double angle, double x0=0, double y0=0)
                {
                    m_rightID.rotate(angle, x0, y0);
                }
                bool operator==(const LanePosition& other)const
                {
                    return this->m_progress == other.m_progress &&
                        this->m_rightID.m_first == other.m_rightID.m_first &&
                        this->m_rightID.m_last == other.m_rightID.m_last;
                }
                std::string toString() const
                {
                    std::stringstream s;
                    s<<m_rightID.toString()<<"@"<<std::setprecision(3)<<m_progress;
                    return s.str();
                }
            };
            struct LanePositionHasher
            {
                std::size_t operator()(const LanePosition& c) const
                {
                    using::std::hash;
                    using::std::size_t;
 
                    BorderIDHasher BIDhasher;
                    size_t hasherBID = BIDhasher(c.m_rightID);
 
                    return (hash<double>()(c.m_progress) ^ hasherBID);
                }
 
                std::size_t operator()(const LanePosition* c) const
                {
                    using::std::hash;
                    using::std::size_t;
 
                    BorderIDHasher BIDhasher;
                    size_t hasherBID = BIDhasher(c->m_rightID);
 
                    return (hash<double>()(c->m_progress) ^ hasherBID);
                }
            };
        }
    }
}