stopline.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
 *   Stephan Lapoehn - initial API and implementation
 ********************************************************************************/
 
#pragma once
#include <adore/env/borderbased/laneposition.h>
#include <adore/env/borderbased/alanepositionedobject.h>
 
namespace adore
{
    namespace env
    {
        namespace BorderBased
        {
            class StopLine:public ALanePositionedObject
            {
            public:
                enum State
                {
                    UNKNOWN = 0,
                    STOP = 1,
                    CONFLICT = 2,
                    GO = 3
                } m_state;
                
                                
                std::map<float,float> m_speedAdvisories; 
                double m_tswitch; 
                LanePosition m_position; 
                int m_signalGroupID; /*<< id of the signal group */
 
                StopLine()
                {
                    m_position=LanePosition();
                    m_state = UNKNOWN;
                    m_tswitch = 1.0e6;
                }
                StopLine(const StopLine& other)
                {
                    this->m_position = other.m_position;
                    this->m_state = other.m_state;
                    this->m_tswitch = other.m_tswitch;
                }
                StopLine(const LanePosition& pos)
                {
                    m_position = LanePosition(pos);
                    m_state = UNKNOWN;
                    m_tswitch = 1.0e6;
                }
                StopLine(const LanePosition& pos, State state,double tswitch = 1.0e6)
                {
                    m_position = LanePosition(pos);
                    m_state = state;
                    m_tswitch = tswitch;
                }
                virtual const LanePosition& getLanePosition()
                {
                    return m_position;
                }
                void translate(double dx,double dy,double dz)
                {
                    m_position.translate(dx,dy,dz);
                }
                void rotate(double angle, double x0=0, double y0=0)
                {
                    m_position.rotate(angle, x0, y0);
                }
                double getSwitchingTime()
                {
                    return m_tswitch;
                }
                void setSwitchingTime(double t)
                {
                    m_tswitch = t;
                }
            };
 
        }
    }
}