lanechangeview.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
 *   Matthias Nichting - initial API and implementation
 ********************************************************************************/
 
#pragma once
#include <adore/env/afactory.h>
#include <adore/view/alanechangeview.h>
#include <adore/env/borderbased/lanechangegeometry.h>
#include <adore/env/borderbased/localroadmap.h>
#include <adore/env/borderbased/lanefollowingview.h>
#include <adore/params/afactory.h>
#include <adore/env/borderbased/conflictset.h>
 
namespace adore
{
namespace env
{
namespace BorderBased
{
class [[deprecated("lanechangeview is superseded by threelaneviewdecoupled")]] DependentLane: public adore::view::ALane
{
private:
  LaneFollowingView* lfv_; 
  LaneChangeGeometry* lcg_;
  adore::env::traffic::EgoLaneTraffic* elt_;   
  adore::env::BorderBased::ConflictSet* cs_;   
public:
  DependentLane(LaneFollowingView* lfv,LaneChangeGeometry* lcg,adore::env::traffic::EgoLaneTraffic* elt,adore::env::BorderBased::ConflictSet* cs)
    :lfv_(lfv),lcg_(lcg),elt_(elt),cs_(cs){}
public:  // methods derived from ALane
  virtual bool isValid() const override
  {
    return lcg_->isValid();
  }
  virtual double getSMax() const override
  {
    return lcg_->getViewingDistance();
  }
  virtual double getSMin() const override
  {
    return 0.0;
  }
  double getProgressOfWidthOpen() const override
  {
      return lcg_->m_s_lane_width_open;
  }
  double getProgressOfWidthClosed() const override
  {
      return lcg_->m_s_lane_width_closed;
  }
  virtual const adore::view::TrafficQueue& getOnLaneTraffic() const override
  {
    return elt_->getQueue();
  }
  virtual const adore::view::ConflictSet& getConflictSet() const override
  {
    return *cs_;
  }
  [[deprecated("lanechangeview is superseded by threelaneviewdecoupled")]]
  virtual double getSpeedLimit(double s) override
  {
    return 40.0;
  }
  [[deprecated("lanechangeview is superseded by threelaneviewdecoupled")]]
  virtual double getLeftIndicatorHint(double s) override { return 0.0; }
 
  [[deprecated("lanechangeview is superseded by threelaneviewdecoupled")]]
  virtual double getRightIndicatorHint(double s) override { return 0.0; }
  virtual bool hasSpeedRecommendation(double s) const override
  {
    return false;
  }
  virtual double getSpeedRecommendation(double s) const override
  {
    return 0.0;
  }
  virtual double getNavigationCost(double s) override
  {
    return 0.0;
  }
  virtual void boundNavigationCost(double s0,double s1,double& cmin,double& cmax) 
  {
    cmin = 0.0;cmax = 0.0;
  }
  virtual double getHeading(double s)override
  {
    return lfv_->getHeading(s);
  }
  virtual double getCurvature(double s, int derivative) override
  {
    return lfv_->getCurvature(s,derivative);
  }
  virtual double getOffsetOfLeftBorder(double s) override
  {
    return lcg_->getOffsetOfLeftBorder(s);
  }
  virtual double getOffsetOfRightBorder(double s) override
  {
    return lcg_->getOffsetOfRightBorder(s);
  }
  virtual void toRelativeCoordinates(double xe,double ye,double& s,double& n) override
  {
    lfv_->toRelativeCoordinates(xe,ye,s,n);
  }
  virtual void toEucledianCoordinates(double s,double n,double& xe,double& ye,double& ze)  override
  {
    lfv_->toEucledianCoordinates(s,n,xe,ye,ze);
  }
};
 
class LaneChangeView : public adore::view::ALaneChangeView
{
private:
  LaneFollowingView* lfv_; 
  LaneChangeGeometry lcg_; 
  LocalRoadMap* lrm_; 
  adore::params::APLaneChangeView* apLCV_; 
  adore::env::traffic::EgoLaneTraffic elt_;   
  adore::env::BorderBased::ConflictSet cs_;   
  DependentLane dl_;
public:
  LaneChangeView(adore::params::AFactory* paramsfactory, LocalRoadMap* localRoadMap,
                 LaneFollowingView* lfv,
                    adore::env::traffic::TrafficMap *trafficMap)
    : lfv_(lfv),lrm_(localRoadMap), elt_(trafficMap),cs_(lfv_->getGeometry()),
      dl_(lfv_,&lcg_,&elt_,&cs_)
  {
    apLCV_ = paramsfactory->getLaneChangeView();
  }
 
  LaneChangeView(LocalRoadMap* localRoadMap, LaneFollowingView* lfv, adore::env::traffic::TrafficMap *trafficMap) 
  : LaneChangeView(adore::params::ParamsFactoryInstance::get(), localRoadMap, lfv, trafficMap)
  {
    
    // LaneChangeView(adore::params::ParamsFactoryInstance::get(), lfv, trafficMap);
  }
 
  [[deprecated("lanechangeview is superseded by threelaneviewdecoupled")]]
  void update(adore::view::ALaneChangeView::direction direction)
  {
    int lfg_adjacency_i_start = 0;
    lcg_.update(lfv_->getGeometry(), lrm_->getBorderSet(), lrm_->getVehicleState(), lfg_adjacency_i_start,
                direction, apLCV_->getLookBehind(), apLCV_->getLookAhead());
    elt_.mapVehiclesOnBorders(lfv_, *lcg_.getOuterBorders());
    cs_.update(lrm_->getBorderSet(),lrm_->getPrecedenceSet(), &elt_, lcg_.getInnerBorders(), lcg_.getOuterBorders());
  }
  LaneChangeGeometry *getGeometry() { return &lcg_; }
 
public:  // methods derived from ALaneChangeView
  virtual adore::view::ALane* getSourceLane()override 
  {
    return lfv_;
  }
  virtual adore::view::ALane* getTargetLane()override
  {
    return &dl_;
  }
  virtual adore::view::ALaneChangeView::direction getLCDirection() const override
  {
    return lcg_.getLCDirection();
  }
  virtual double getProgressOfGateOpen() const override
  {
    return lcg_.getProgressOfGateOpen();
  }
  virtual double getProgressOfGateClosed() const override
  {
    return lcg_.getProgressOfGateClosed();
  }
  virtual double getOffsetOfStartOuterBorder(double s)  override
  {
    if (getLCDirection() == adore::view::ALaneChangeView::LEFT)
    {
      return lfv_->getGeometry()->getOffsetOfRightBorder(s);
    }
    return lfv_->getGeometry()->getOffsetOfLeftBorder(s);
  }
  virtual double getOffsetOfSeparatingBorder(double s) override
  {
    if (getLCDirection() == adore::view::ALaneChangeView::RIGHT)
    {
      return lfv_->getGeometry()->getOffsetOfRightBorder(s);
    }
    return lfv_->getGeometry()->getOffsetOfLeftBorder(s);
    //return lcg_.getOffsetOfCenterBorder(s);
  }
  virtual double getOffsetOfDestinationOuterBorder(double s) override
  {
    if (getLCDirection() == adore::view::ALaneChangeView::RIGHT)
    {
      return lcg_.getOffsetOfRightBorder(s);
    }
    return lcg_.getOffsetOfLeftBorder(s);
  }
  virtual double getNavigationCostDifference() override
  {
      return 0.0;
  }
 
 
};
}  // namespace BorderBased
}  // namespace env
}  // namespace adore