conflictset.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 <vector>
#include "trafficobject.h"
#include "limitline.h"
 
namespace adore
{
namespace view
{
class ConflictZone
{
private:
    double startProgress_;      
    double endProgress_;        
    bool hasEndProgress_;       
    double waitingPosition_;    
    bool hasPriority_;          
    TrafficQueue crossTraffic_; 
    LimitLine limitLine_;       
public:
    ConflictZone()
    {
        startProgress_ = std::numeric_limits<double>::max();
        startProgress_ = std::numeric_limits<double>::min();
        hasEndProgress_ = false;
        hasPriority_ = true;
    }
    double getStartProgress() const
    {
        return startProgress_;
    }
    double getEndProgress() const
    {
        return endProgress_;
    }
    bool hasEndProgress() const
    {
        return hasEndProgress_;
    }
    double getWaitingPosition() const
    {
        return waitingPosition_;
    }
    bool hasPriority() const
    {
        return hasPriority_;
    }
    /*
    * getCrossTraffic - returns a set of traffic objects approaching the conflict zone with higher priority.
    * The AV has to yield to cross traffic, before entering a conflict zone.
    * Cross traffic is ordered by EntranceTime.
    */
    TrafficQueue *getCrossTraffic()
    {
        return &crossTraffic_;
    }
    const LimitLine &getLimitLine() const
    {
        return limitLine_;
    }
 
public:
    void setStartProgress(double value)
    {
        startProgress_ = value;
    }
    void setEndProgress(double value)
    {
        endProgress_ = value;
    }
    void setHasEndProgress(bool value)
    {
        hasEndProgress_ = value;
    }
    void setWaitingPosition(double value)
    {
        waitingPosition_ = value;
    }
    void setPriority(bool value)
    {
        hasPriority_ = value;
    }
    void setCrossTraffic(TrafficQueue &trafficqueue)
    {
        crossTraffic_ = trafficqueue;
    }
    void setLimitLine(LimitLine &limitline)
    {
        limitLine_ = limitline;
    }
};
class ConflictArea
{
public:
 
    ConflictArea() = default;
    // TODO investigate if calling delete on derived classes will cause memory leaks
    virtual ~ConflictArea() = default; // -Wdelete-non-virtual-dtor
 
    virtual unsigned int getNumberOfConflictZones() const = 0;
    
    virtual double getStartProgress() const=0;
    
    virtual double getEndProgress() const=0;
   
    virtual bool hasEndProgress() const=0;
    
    virtual double getWaitingPosition() const=0;
    
    virtual std::vector<ConflictZone*> getConflictZones() const = 0;
};
class ConflictSet
{
public:
    virtual bool isValid() const = 0;
    virtual std::vector<ConflictArea*> getConflictAreas() const = 0; // TODO 
};
} // namespace view
} // namespace adore